In case you missed 🚨

✨ create-near-app v9.0 quietly crossed an important line ✨

What’s new:
➡️ Frontend templates now use near-connector, providing most of the functionality previously handled by wallet-selector while reducing dependencies and simplifying the setup.

➡️ Smart contract templates no longer rely on a minimal hello-world example. New projects now include an auction contract that demonstrates additional concepts such as structs, deposits, and timestamps.

Why this matters:
The default project scaffold now exposes developers to a broader set of NEAR primitives from the start. This reduces the gap between an initial scaffold and the patterns required when building non-trivial applications ✅

Release details and changelog are available here 👈

🟦 Channel | Chat | LinkTree

Indexing almost always turns into a separate task.

History, filtering, rebuilding datasets, delays between events and UI all of this quickly stops fitting into simple RPC calls 👨‍💻

In the NEAR ecosystem, there’s an indexing-focused tool called Goldsky.

It reads NEAR data sequentially and streams it into external storage systems like Postgres, ClickHouse, S3, or Kafka. This keeps indexing and data handling outside the application itself.

For a more detailed look, watch the video. You'll see how this works in practice 👀

A trial version is available to everyone. Feel free to try it out. However, it has limitations. You can find more details about them here.

That’s one of the indexing options currently available on NEAR ✅

🟦 Channel | Chat | LinkTree

Unverifiable AI is an enterprise risk

That’s why NEAR AI joining the NVIDIA Inception Program matters.

This isn’t about branding or acceleration credits. It’s about access to infrastructure that enables enterprise-grade, verifiable AI, specifically through NVIDIA Confidential Computing.

➡️ Here’s the core problem.

Most AI systems protect data at rest and in transit. But once execution begins, models and inputs live in memory that is typically accessible to the host operating system or the underlying infrastructure.

That’s the trust gap.

➡️ NVIDIA Confidential Computing changes this execution model.

In the NEAR AI stack, workloads run inside hardware-isolated environments where memory remains encrypted during execution, and the execution itself can be cryptographically verified.

It’s not just encryption. It’s secure computation with verifiable privacy guarantees 🔒

🔗 Read more here

🟦 Channel | Chat | LinkTree

NEARCON Innovation Sandbox is starting soon.

A global, virtual-first builder sprint running Jan 26 – Feb 16, designed to help teams move beyond experiments and prepare for mainnet deployment 👨‍💻

Focus areas: decentralized AI, privacy-preserving consumer apps, and intent-driven commerce.

Builders will work with NEAR’s stack and receive hands-on technical support through virtual workshops and DevRel office hours, focused on implementation and troubleshooting.

➡️ Selected projects will be presented at NEARCON in San Francisco (Feb 23–24)
➡️ Prizes: up to $15,000

Details and registration here 👈

🟦 Channel | Chat | LinkTree

⚠️ Heads-up: possible increase of function call gas limit ⚠️

We’ve received information about a potential change to increase the maximum gas that can be attached to certain function calls from 300 TGas to 1000 TGas (1 PGas).

While this change aims to improve flexibility for more complex calls, a possible compatibility issue was highlighted:
🟡 Some existing contracts may have callbacks that rely on a hardcoded gas assumption (e.g. 300 TGas)
🟡 If more gas is attached to the original call, such callbacks could receive more gas than expected
🟡 This may lead to unexpected behavior in contracts that depend on strict gas limits

At this stage, we are collecting feedback from developers to better understand whether this change could affect existing contracts ✍️

Please share your thoughts if:
🟡 Your callbacks assume a fixed gas limit
🟡 Your contract logic depends on gas-based assumptions
🟡 You see any potential risks if callbacks are executed with more than 300 TGas

Any insights or examples would be very helpful.
Thanks in advance for your feedback 🙏

🟦 Channel | Chat | LinkTree

In case you missed 🚨

✨ near-api-js v7.0.0 has been released ✨

Key changes:
➡️ Core functionality is now consolidated into a single near-api-js package
➡️ Explicit unit helpers: nearToYocto, yoctoToNear, teraToGas, gigaToGas
➡️ Built-in subpaths without extra dependencies: tokens, nep413, seedPhrase
➡️ Improved parallel transaction handling with automatic nonce management and MultiKeySigner

Why it matters:
Less fragmentation, clearer primitives, and fewer edge cases when building real applications. Breaking changes are minimal, migration from v6 (and even v5) should be simple ✅

For details, see the release notes and the thread 🖥

🟦 Channel | Chat | LinkTree

Rust dev tools on NEAR are being reworked 🏊‍♀️

NEAR is reshaping its Rust tooling to reduce churn and long-term maintenance overhead. Less dependency on nearcore, clearer boundaries between tools, and a more stable structure.

near-api-rs is becoming the central layer. RPC clients are generated from OpenAPI. Older tools are gradually phased out. near-sdk-rs is preparing for its next major update.

The changes are structural rather than cosmetic ✅

What’s changing and why 🖥

🟦 Channel | Chat | LinkTree

Not sure whether NEARCON Innovation Sandbox is for you? Find out today 🔎

The Innovation Sandbox kickoff livestream goes live at 4 PM UTC.

This session opens the sprint and sets the context around what it is, what it focuses on, and how it’s structured. There will be space to talk through the bounties, discuss the technical direction, brainstorm ideas, and ask questions live.

If you’re curious and want context before deciding to join, the livestream is the right place to start 💯

📺 Watch the livestream
✍️ Register for the NEARCON Innovation Sandbox

🟦 Channel | Chat | LinkTree

In case you missed 🚨

✨ NEAR DNS ✨

Vlad Frolov experimented with an AI agent and wired DNS to NEAR 👨‍💻

The result is a DNS resolver that reads records from NEAR accounts and continues to answer queries through the standard DNS protocol. From the client side, it behaves like regular DNS with no new formats or special tooling.

In the post, Vlad walks through the idea, the constraints of this approach, and why this setup works in practice.

If this sounds interesting, it’s best to read the details on Reddit 👈

🟦 Channel | Chat | LinkTree

Sometimes all NEAR builders need is that one missing piece 🧩

With Awesome NEAR there is nothing to search for. All NEAR tools are in one place. SDKs, wallets, infra, RPCs, indexers, data tools, examples, and more.

If you’re building, save this so you don’t lose it 🔖

🟦 Channel | Chat | LinkTree

In case you missed 🚨

🔐 near-multisig-sdk 🔓

This repository was shared in the NEAR Tools chat 💬

It implements multisig on NEAR using a contract-controlled account. A contract collects approvals from multiple participants and executes a transaction once the threshold is met.

A simple example of how multisig can be built by the community directly on top of NEAR accounts, without off-chain coordination ✅

🧗 Repository

Feedback from anyone who has worked with multisig is welcome ✍️

🟦 Channel | Chat | LinkTree

🚨 Going live in 1 hour

What does “NEAR is the BOS” actually mean today?

Join the Innovation Sandbox workshop to explore how the NEAR tech stack has evolved and why it’s suited for building decentralized apps. Live walkthrough, build, and deployment included ✅

🎙 Hosted by @ejlbraem
📺 Live on YouTube and X (Twitter)

🟦 Channel | Chat | LinkTree

Confidential email implemented on NEAR

near.email is an email service built around NEAR. Visually, it looks like a regular email client and uses standard SMTP. The difference is privacy.

What changes:
➡️ access and message decryption are tied to the NEAR account
➡️ there are no provider-held credentials
➡️ messages are processed inside a TEE
➡️ emails are stored encrypted, so the service can’t read them

Email is not stored or processed on-chain. The NEAR account is used for identity and access control, while email remains fully off-chain and compatible with existing infrastructure.

This is a working implementation you can test today (early access).

We’re sharing 5 invite codes to get started: 1 / 2 / 3 / 4 / 5
Each activated account receives 3 more codes.

As a result, NEAR Email can be seen alongside NEAR AI, NEAR Web4, and NEAR DNS as a practical example of applications built around NEAR accounts. Docs 🖥

🟦 Channel | Chat | LinkTree

🚨 Going live in 1 hour

How does NOVA approach privacy-first, decentralized file sharing?

Join Innovation Sandbox [Workshop 2]: Building with NOVA for a deep dive into the NOVA tech stack and how it’s designed for encrypted data persistence in dApps ✅

📺 Live on YouTube and X (Twitter)

🟦 Channel | Chat | LinkTree

OpenClaw is now available on NEAR AI Cloud 🦞 🛡

OpenClaw is a personal agent that actually works. It connects to email and services, keeps context, and runs 24/7. It feels more like a quiet coworker than a chatbot.

Until now, running it meant an awkward trade-off.
1️⃣ Either keep everything on local hardware.
2️⃣ Or run it on a standard cloud VM and accept that memory, keys, and context live in an untrusted environment.

There’s now a third option.

3️⃣ OpenClaw can run on NEAR AI Cloud inside a TEE.

What this changes:
✦ memory and data are encrypted at the hardware level
✦ only verified code is allowed to run
✦ the infrastructure has no visibility into the agent, even from NEAR AI

The agent can keep long-term memory and work with real tools while staying inside an encrypted execution environment 🛡

If you’ve wanted to run OpenClaw without managing your own hardware or trusting a regular cloud VM, NEAR AI Cloud makes that possible.

Apply for early access ✍️

🟦 Channel | Chat | LinkTree

✉️ NEAR Dev News #84 — The January Issue

From enterprise AI to developer tooling and ecosystem momentum, here’s what shaped NEAR in January.

Here’s the rundown:
➡️ NEAR AI joined the NVIDIA Inception program
➡️ HOT Pay launched as a B2B payment layer built on NEAR Intents
➡️ Rust developer tooling rework continued across the NEAR stack
➡️ NEARCON Innovation Sandbox is underway
… and more inside the full issue.

🧗 Read the full issue & subscribe: https://docs.near.org/newsletter
🔖 Explore active freelancing opportunities: https://nearn.io/

🟦 Channel | Chat | LinkTree

🚨 Going live in 1 hour

How do you stream NEAR data in real time without traditional indexing?

Join Innovation Sandbox [Workshop 3]: Streaming NEAR Data with Goldsky to go under the hood of Goldsky Mirror and see how NEAR data can be streamed directly into your database.

📺 Live on YouTube and X (Twitter)

🟦 Channel | Chat | LinkTree

NEAR skills + AI agents = agents that actually do things 👨‍💻

An agent does not know everything by default. Like a human, it is shaped by its skills.

The difference is that agent skills are modular and reusable capabilities that work across different agent platforms and workflows, such as OpenClaw, Claude Code, and Codex.

NEAR has its own set of these skills.

These are the skills your AI agent will brag about on the forum:
➡️ near-ai
➡️ near-api-js
➡️ near-connect
➡️ near-connect-hooks
➡️ near-kit
➡️ near-intents
➡️ near-smart-contracts
They are available here 🧗

With these skills, your agent will be valued not only on Moltbook, but also on Agent Market. On that note...

... this is a good moment not just to launch your onchain AI agent, but to start exploring its first paid tasks.

Be among the first to try it 🖥

🟦 Channel | Chat | LinkTree

🚨 Going live in 1 hour

How does PingPay approach payment orchestration across assets?

Join Innovation Sandbox [Workshop 4]: Exploring PingPay for a walkthrough of the PingPay tech stack and how it’s used for payment scenarios powered by NEAR Intents ✅

📺 Live on YouTube and X (Twitter)

🟦 Channel | Chat | LinkTree

The Unified Commerce Layer by Illia Polosukhin

In his latest Substack piece, Illia writes that “commerce” is the world’s value-movement layer, and AI is about to automate it end-to-end.

He connects that shift to NEAR Intents as neutral infrastructure that routes intents to execution, and points to Agent Market as an early example: agents hiring agents, with work settled through escrow.

🔖 Read the full piece & subscribe

🟦 Channel | Chat | LinkTree

Vadim Zavodil announced an on-demand oracle on NEAR

✨ TEE-Secured Price Oracle ✨

It fetches fresh data inside Intel TDX and returns it to your contract via callback, without the usual “keep updating the feed” loop.

Here’s what it actually gives you in practice:
➡️ Prices are always “warm” in TEE
➡️ Zero trust execution inside Intel TDX
➡️ 9+ price sources with median aggregation
➡️ Pyth-compatible API for easy migration
➡️ Custom data fetching from any HTTP API
➡️ Subsidized calls when the contract is funded

Powered by OutLayer ✅

🧗 For details, see the full thread
🧗 Try it here

🟦 Channel | Chat | LinkTree