撸毛研究院

Lihat terjemahan

#dusk $DUSK @Dusk 这几年看链上协议出问题，我养成了一个习惯：不太关心黑客有没有暴力破解，反而先看掌握网络共识安全的核心组件，到底靠什么机制把验证者死死按住了。见过太多节点作恶，根子不是算法被攻破，是共识设计从一开始就默认“验证者会老实听话”，这个默认只要失效一次，罚没机制就会沦为空谈。

最近拆解 Dusk 的 SA 共识与 Slashing 设计时，让我停下来的正是这一层。@Dusk

Dusk 的 Succinct Attestation（SA）共识采用委员会型 PoS 模型，通过确定性抽签算法选出出块者和投票委员会。它把恶意行为和过失行为分开处理，对应 Hard Slashing 和 Soft Slashing 两套机制。Soft Slashing 针对节点未出块这类非恶意过失——第一次警告，之后每次连续违规扣除 N×10% 的质押权益并从共识中移除 N 个 epoch，但罚没的 DUSK 不销毁，只是从活跃质押中移除，节点仍可提取。Hard Slashing 则针对明确恶意行为：生成无效区块扣 10% 质押并销毁，双重投票或双倍出块扣 20% 并销毁。这套设计让 Dusk 具备可追责性，但验证者一旦作恶代价极重。

我也不会把它捧上天。架构再精妙，如果验证者为了降低运维成本而集中托管节点，或者长期在线率低于 95% 触发 Soft Slashing 累积扣减，协议精心构建的安全边界就会面临真正考验。未来若为了省事把验证节点集中在少数几个实体手里，所谓的“去中心化”就只剩心理安慰。

在我看来 $DUSK 的价值最终看有多少验证者愿意为了安全牺牲便利。以后合规资产上链会越来越多，我更在意的不是收益率有多高，是谁能证明在巨大的利益诱惑面前，这套让作恶者付出真金白银代价的机制依然能被严格执行。

#termmax @termmax 翻TermMax主网V2的链上交互日志时，最先让我停下来的不是TVL破亿的增长数据，是它把「资金归集」和「到期计息」拆成了两个完全独立的权限域。入金进来的资产先落在公共Deposit Pool里，这是个仅支持充值、提现的中转账户，不能直接生成计息头寸。想参与固定收益策略得手动把指定金额划转进对应到期日的Term Segment分片，这步操作会自动触发链上时间锁校验，没有任何后门可以跳过。资金全程待在隔离的静态池，计息权限单独开了一道独立的执行门。这套权限逻辑我在券商固收托管系统里见得很多，之前帮朋友做资管系统外包的时候，光资金隔离这块就改了三版需求，机构做大额资金管理，资金调拨和产品计息清算从来不会共用同一套密钥。但链上绝大多数借贷协议默认钱包地址等于全量操作权限，上个月群里还有个兄弟私钥漏了半仓USDC直接被转空，连申诉的地方都找不到。TermMax文档里标注的TBAC时间基访问控制，走的就是这个隔离思路，和Aave的全局统一权限体系完全不同，连治理多签都没有修改Term Segment到期参数的权限，让每一步操作只对应它该有的最小权限。顺着这条线看它的固定到期原语架构，逻辑完全自洽。上层产品组合层开放接口，对接各类结构化收益工具做玩法延伸；底层清算层完全锚定Term Auction荷兰拍卖模块做最终链上执行。专业资金不用为了稳定收益牺牲资产隔离性，所有到期状态又能全节点可验证。我觉得TermMax真正在解决的，对大额资金来说，缺的从来不是年化收益，是一套能完全信任的时间边界规则。当然假如，极端行情下大量头寸同步到期时，系统能不能扛住集中清算的压力，还要再观察。但这个设计思路让我觉得，链上固收要承接更大体量的资金，从来不是单纯拼收益率这么简单。

Lihat terjemahan

#termmax @TermMax 翻TermMax主网V2的链上交互日志时，最先让我停下来的不是TVL破亿的增长数据，是它把「资金归集」和「到期计息」拆成了两个完全独立的权限域。
入金进来的资产先落在公共Deposit Pool里，这是个仅支持充值、提现的中转账户，不能直接生成计息头寸。想参与固定收益策略得手动把指定金额划转进对应到期日的Term Segment分片，这步操作会自动触发链上时间锁校验，没有任何后门可以跳过。资金全程待在隔离的静态池，计息权限单独开了一道独立的执行门。
这套权限逻辑我在券商固收托管系统里见得很多，之前帮朋友做资管系统外包的时候，光资金隔离这块就改了三版需求，机构做大额资金管理，资金调拨和产品计息清算从来不会共用同一套密钥。但链上绝大多数借贷协议默认钱包地址等于全量操作权限，上个月群里还有个兄弟私钥漏了半仓USDC直接被转空，连申诉的地方都找不到。TermMax文档里标注的TBAC时间基访问控制，走的就是这个隔离思路，和Aave的全局统一权限体系完全不同，连治理多签都没有修改Term Segment到期参数的权限，让每一步操作只对应它该有的最小权限。
顺着这条线看它的固定到期原语架构，逻辑完全自洽。上层产品组合层开放接口，对接各类结构化收益工具做玩法延伸；底层清算层完全锚定Term Auction荷兰拍卖模块做最终链上执行。专业资金不用为了稳定收益牺牲资产隔离性，所有到期状态又能全节点可验证。
我觉得TermMax真正在解决的，对大额资金来说，缺的从来不是年化收益，是一套能完全信任的时间边界规则。
当然假如，极端行情下大量头寸同步到期时，系统能不能扛住集中清算的压力，还要再观察。但这个设计思路让我觉得，链上固收要承接更大体量的资金，从来不是单纯拼收益率这么简单。

#termmax @termmax Selesai membaca dokumentasi teknis TermMax V2, dan yang paling menusuk bagi saya sebenarnya adalah kalimat yang saya lihat saat mengelap layar semalam—sambil duduk di sofa menunggu, saya mengunyah dokumen, setengah gelas es cola tumpah ke keyboard. Begitu saya mengelap layar, barulah saya menyadari penjelasan itu yang cukup mudah terlewat: TermMax sendiri bukan produk pinjaman, melainkan sebuah primitive aset jatuh tempo tetap; produk yield yang sebenarnya dan alat-alat terstruktur adalah yang dipasang/ditambahkan dari luar. Saat itu saya mengelap noda cola sambil menatap layar, sempat bengong setengah menit. Setelah saya lanjut baca ke bawah, barulah saya paham: begitu sebuah kontrak pinjaman dengan jangka waktu tetap dibuat, waktu jatuh tempo, ambang likuidasi, dan jenis mata uang untuk settlement langsung “dikunci” di atas rantai (on-chain), bukan disimpan dulu lalu kemudian parameter diubah secara dinamis. Intinya, kontrak ini sejak lahir sudah tahu kapan dia jatuh tempo, bagaimana cara dilikuidasi, dan memakai settlement pakai apa—berbeda total dengan model pinjaman perpetual seperti Aave atau Compound yang biasanya “deposit dulu, lalu suku bunga bisa berubah kapan saja, garis likuidasi bisa disesuaikan kapan saja”. Bayangan tahun lalu saat saya menyetor ETH di Aave dan tiba-tiba terkena jarum (disengat) likuidasi sampai terseret keluar separuh posisi langsung muncul lagi. Pengguna sama sekali tidak perlu khawatir tiba-tiba disuntik likuidasi di tengah jalan atau suku bunga anjlok. Data industri mengatakan sekarang di DeFi, lebih dari 90% aktivitas pinjaman menggunakan skema perpetual dengan suku bunga mengambang, sedangkan porsi fixed income kurang dari 10%. Setelah melihat desain ini, saya kira saya mengerti kenapa fixed income dulu susah sekali diwujudkan—bukan karena pengguna tidak butuh, tapi karena primitive dasarnya belum dibuat dengan benar. Coba ikuti produk terstruktur fixed income berjenis bertingkat yang baru diluncurkannya, akan makin jelas. Contohnya: USDC disimpan ke TermMax dalam kontrak periode tetap 90 hari. Statusnya kemudian berubah di sisi protokol strukturasi eksternal menjadi semacam sertifikat/pasar berlapis untuk imbal hasil: prioritasnya mengambil fixed interest, sedangkan lapisan subordinat (junior) menanggung/memakan excess return. Saat jatuh tempo, pokok plus bunga otomatis diselesaikan—tanpa perlu redeem manual dari pengguna. Kalau aset jaminan di bawah jatuh melampaui garis likuidasi, kontrak akan otomatis memicu likuidasi lelang ala Belanda (Dutch auction). Sepanjang proses tidak ada pemungutan suara tata kelola (governance) dan tidak butuh campur tangan manusia. Agar likuidasinya bisa semulus itu, dasarnya adalah time-lock native + modul lelang on-chain yang menuliskan logika likuidasi langsung ke lapisan kontrak. Dibanding model tradisional pinjaman yang bergantung pada pihak ketiga untuk menjadi “likuidator” yang kebut duluan, ini jauh lebih stabil, dengan biaya Gas 60% lebih rendah. Cara kerjanya juga beda total: bukan seperti pinjaman on-demand yang terus mengirim harga (real-time) dan melakukan likuidasi real-time—ini benar-benar jalur yang berbeda. Gagasan “biarkan produk dipegang/diteruskan oleh pihak lain untuk membangun” inilah—dan pendekatan desain seperti inilah—alasan mendasar mengapa ia bisa terus melahirkan variasi produk baru tanpa harus setiap kali menciptakan roda dari nol.

Sebagian Benar

#termmax @TermMax Selesai membaca dokumentasi teknis TermMax V2, dan yang paling menusuk bagi saya sebenarnya adalah kalimat yang saya lihat saat mengelap layar semalam—sambil duduk di sofa menunggu, saya mengunyah dokumen, setengah gelas es cola tumpah ke keyboard. Begitu saya mengelap layar, barulah saya menyadari penjelasan itu yang cukup mudah terlewat: TermMax sendiri bukan produk pinjaman, melainkan sebuah primitive aset jatuh tempo tetap; produk yield yang sebenarnya dan alat-alat terstruktur adalah yang dipasang/ditambahkan dari luar.

Saat itu saya mengelap noda cola sambil menatap layar, sempat bengong setengah menit. Setelah saya lanjut baca ke bawah, barulah saya paham: begitu sebuah kontrak pinjaman dengan jangka waktu tetap dibuat, waktu jatuh tempo, ambang likuidasi, dan jenis mata uang untuk settlement langsung “dikunci” di atas rantai (on-chain), bukan disimpan dulu lalu kemudian parameter diubah secara dinamis. Intinya, kontrak ini sejak lahir sudah tahu kapan dia jatuh tempo, bagaimana cara dilikuidasi, dan memakai settlement pakai apa—berbeda total dengan model pinjaman perpetual seperti Aave atau Compound yang biasanya “deposit dulu, lalu suku bunga bisa berubah kapan saja, garis likuidasi bisa disesuaikan kapan saja”. Bayangan tahun lalu saat saya menyetor ETH di Aave dan tiba-tiba terkena jarum (disengat) likuidasi sampai terseret keluar separuh posisi langsung muncul lagi. Pengguna sama sekali tidak perlu khawatir tiba-tiba disuntik likuidasi di tengah jalan atau suku bunga anjlok.

Data industri mengatakan sekarang di DeFi, lebih dari 90% aktivitas pinjaman menggunakan skema perpetual dengan suku bunga mengambang, sedangkan porsi fixed income kurang dari 10%. Setelah melihat desain ini, saya kira saya mengerti kenapa fixed income dulu susah sekali diwujudkan—bukan karena pengguna tidak butuh, tapi karena primitive dasarnya belum dibuat dengan benar.

Coba ikuti produk terstruktur fixed income berjenis bertingkat yang baru diluncurkannya, akan makin jelas. Contohnya: USDC disimpan ke TermMax dalam kontrak periode tetap 90 hari. Statusnya kemudian berubah di sisi protokol strukturasi eksternal menjadi semacam sertifikat/pasar berlapis untuk imbal hasil: prioritasnya mengambil fixed interest, sedangkan lapisan subordinat (junior) menanggung/memakan excess return. Saat jatuh tempo, pokok plus bunga otomatis diselesaikan—tanpa perlu redeem manual dari pengguna. Kalau aset jaminan di bawah jatuh melampaui garis likuidasi, kontrak akan otomatis memicu likuidasi lelang ala Belanda (Dutch auction). Sepanjang proses tidak ada pemungutan suara tata kelola (governance) dan tidak butuh campur tangan manusia. Agar likuidasinya bisa semulus itu, dasarnya adalah time-lock native + modul lelang on-chain yang menuliskan logika likuidasi langsung ke lapisan kontrak. Dibanding model tradisional pinjaman yang bergantung pada pihak ketiga untuk menjadi “likuidator” yang kebut duluan, ini jauh lebih stabil, dengan biaya Gas 60% lebih rendah. Cara kerjanya juga beda total: bukan seperti pinjaman on-demand yang terus mengirim harga (real-time) dan melakukan likuidasi real-time—ini benar-benar jalur yang berbeda.

Gagasan “biarkan produk dipegang/diteruskan oleh pihak lain untuk membangun” inilah—dan pendekatan desain seperti inilah—alasan mendasar mengapa ia bisa terus melahirkan variasi produk baru tanpa harus setiap kali menciptakan roda dari nol.

AAVE+8,15%

USDC-0,02%

#dusk $DUSK @Dusk_Foundation Pertama kali saya melihat Dusk menyebut Selective Disclosure (pengungkapan selektif), saya sebenarnya tidak terlalu memikirkannya. Saat itu, pemahaman saya sangat sederhana: bukankah protokol privasi itu berarti menyembunyikan informasi transaksi? Melindungi jumlah, alamat, dan relasi transaksi agar orang lain tidak bisa melihatnya—tidakkah itu sudah memenuhi perlindungan privasi? Sampai beberapa hari lalu, ketika saya merapikan catatan whitepaper Dusk, saya menyatukan model transaksi Phoenix dengan skenario aset yang tunduk pada kepatuhan. Saat saya membaca bagian Selective Disclosure, saya berhenti sejenak. Karena saya menyadari ada masalah yang sebelumnya saya abaikan: jika Phoenix sudah menyembunyikan status transaksi, maka bagaimana institusi, auditor, dan regulator—secara tepat—memastikan bahwa transaksi ini mematuhi aturan? Pertanyaan ini membuat saya memahami ulang rancangan Dusk. Semula saya pikir inti privasi adalah “agar orang lain tidak melihat”. Namun setelah meneliti, saya baru sadar bahwa yang benar-benar dibutuhkan institusi bukanlah menyembunyikan sepenuhnya, melainkan mengendalikan kapan, kepada siapa, dan dengan cara apa informasi diverifikasi. Phoenix memecahkan privasi transaksi itu sendiri. Melalui shielded notes dan zero-knowledge proofs, jaringan dapat memverifikasi validitas transaksi tanpa harus mempublikasikan saldo lengkap, relasi transaksi, dan status aset. Namun untuk aset yang teregulasi seperti sekuritas, reksa dana, dan sejenisnya, hanya menyembunyikan informasi tidaklah cukup; pasar keuangan membutuhkan audit, perlu memastikan aturan dijalankan, dan juga memerlukan bukti pada kondisi tertentu. Di sinilah Selective Disclosure memiliki maknanya. Ini bukanlah upaya untuk merusak privasi, melainkan membangun “jalur verifikasi” di atas privasi: secara default melindungi data transaksi, dan ketika pihak yang berwenang perlu memeriksa, hanya informasi yang diperlukan yang diungkap—bukan seluruh riwayat transaksi. Setelah menyambungkan dua mekanisme ini, barulah saya mengerti bahwa Phoenix dan Selective Disclosure bukanlah dua modul yang terpisah. Yang pertama menjawab “bagaimana menyembunyikan sekaligus membuktikan transaksi itu benar”, sedangkan yang kedua menjawab “setelah disembunyikan, bagaimana memenuhi aturan keuangan di dunia nyata”. Masalah masa lalu pada blockchain yang transparan adalah kurangnya privasi, sedangkan masalah pada keuangan tradisional adalah informasi yang bisa dikendalikan tetapi bergantung pada verifikasi terpusat. Yang berubah bukan sekadar cara menyembunyikan informasi, melainkan batas kepercayaan dalam keuangan on-chain. Ke depan, ketika RWA benar-benar masuk ke on-chain, tantangannya tidak hanya soal penerbitan Token, melainkan bagaimana membuat aset sekaligus memenuhi privasi, kepatuhan, dan eksekusi otomatis.

Terverifikasi

#dusk $DUSK @Dusk Pertama kali saya melihat Dusk menyebut Selective Disclosure (pengungkapan selektif), saya sebenarnya tidak terlalu memikirkannya. Saat itu, pemahaman saya sangat sederhana: bukankah protokol privasi itu berarti menyembunyikan informasi transaksi? Melindungi jumlah, alamat, dan relasi transaksi agar orang lain tidak bisa melihatnya—tidakkah itu sudah memenuhi perlindungan privasi?

Sampai beberapa hari lalu, ketika saya merapikan catatan whitepaper Dusk, saya menyatukan model transaksi Phoenix dengan skenario aset yang tunduk pada kepatuhan. Saat saya membaca bagian Selective Disclosure, saya berhenti sejenak. Karena saya menyadari ada masalah yang sebelumnya saya abaikan: jika Phoenix sudah menyembunyikan status transaksi, maka bagaimana institusi, auditor, dan regulator—secara tepat—memastikan bahwa transaksi ini mematuhi aturan?

Pertanyaan ini membuat saya memahami ulang rancangan Dusk. Semula saya pikir inti privasi adalah “agar orang lain tidak melihat”. Namun setelah meneliti, saya baru sadar bahwa yang benar-benar dibutuhkan institusi bukanlah menyembunyikan sepenuhnya, melainkan mengendalikan kapan, kepada siapa, dan dengan cara apa informasi diverifikasi.

Phoenix memecahkan privasi transaksi itu sendiri. Melalui shielded notes dan zero-knowledge proofs, jaringan dapat memverifikasi validitas transaksi tanpa harus mempublikasikan saldo lengkap, relasi transaksi, dan status aset. Namun untuk aset yang teregulasi seperti sekuritas, reksa dana, dan sejenisnya, hanya menyembunyikan informasi tidaklah cukup; pasar keuangan membutuhkan audit, perlu memastikan aturan dijalankan, dan juga memerlukan bukti pada kondisi tertentu.

Di sinilah Selective Disclosure memiliki maknanya. Ini bukanlah upaya untuk merusak privasi, melainkan membangun “jalur verifikasi” di atas privasi: secara default melindungi data transaksi, dan ketika pihak yang berwenang perlu memeriksa, hanya informasi yang diperlukan yang diungkap—bukan seluruh riwayat transaksi.

Setelah menyambungkan dua mekanisme ini, barulah saya mengerti bahwa Phoenix dan Selective Disclosure bukanlah dua modul yang terpisah. Yang pertama menjawab “bagaimana menyembunyikan sekaligus membuktikan transaksi itu benar”, sedangkan yang kedua menjawab “setelah disembunyikan, bagaimana memenuhi aturan keuangan di dunia nyata”. Masalah masa lalu pada blockchain yang transparan adalah kurangnya privasi, sedangkan masalah pada keuangan tradisional adalah informasi yang bisa dikendalikan tetapi bergantung pada verifikasi terpusat.

Yang berubah bukan sekadar cara menyembunyikan informasi, melainkan batas kepercayaan dalam keuangan on-chain. Ke depan, ketika RWA benar-benar masuk ke on-chain, tantangannya tidak hanya soal penerbitan Token, melainkan bagaimana membuat aset sekaligus memenuhi privasi, kepatuhan, dan eksekusi otomatis.

Lihat terjemahan

#termmax @TermMax 上周刷链上收益榜单偶然刷到TermMax的时候，它的TVL才刚摸到7100万，我对着它的借贷利率曲线翻了十分钟，觉得产品逻辑挺顺但毕竟是新项目，总觉得"再观察两周，等数据稳点再进"，随手把合约地址存进了我的观察钱包，转头就去忙别的事了。

上周刷链上数据看板，看见它TVL冲到9000万的时候，我盯着观察钱包里的空地址犹豫了五分钟，手指都放到确认转账的按钮上了，最后还是缩了回来，总觉得"涨这么快肯定有回调空间，再等等能拿到更舒服的仓位"，还自我安慰反正没踏空行情，晚两天进也不亏。

昨晚刷官方公告看见它TVL正式破亿，我坐起来翻完了它的全量链上数据。翻到产品架构那一页我真正看进去了——FT以折扣价买入、到期按面值赎回，GT把抵押物和债务打包成独立头寸。以前我看固定利率协议最怕资金闲置，挂单等匹配时钱就卡着不动。TermMax直接把底层接到Morpho，挂单时自动跑浮动收益，撮合成功无缝切固定利率。这套逻辑比我预想的成熟得多，但越成熟，我越后悔——当初怎么就没下手呢？上线才一年就从主网迭代到V2版本，已经部署了10条EVM链，总用户直接破了110万，这完全不是靠短期挖矿激励堆出来的虚高数据，是真的有大量用户在高频使用它的借贷产品。

之前炒山寨币浮亏几万我都没这么难受，亏钱是自己踩坑认栽，割肉就能重来。但这种遗憾完全不一样，你明明从最早期就看见了它，两次站在车门口都没抬脚上去，眼睁睁看着它从"有潜力的新项目"长成赛道头部，每一步增长你都看在眼里，却全因为自己的犹豫错过了。

我现在又盯着观察钱包的空地址发呆，有没有老玩家说句实话，现在上车$TMX还来得及不？@TermMax

Sebagian Benar

Lihat terjemahan

#dusk $DUSK 这几年看隐私链翻车，我慢慢养成一个习惯：不太关心加密算法有没有被破解，反而先看留着合规后门的那个人到底被约束住了没有。见过太多隐私项目暴雷，根子不是零知识证明被攻破，是权限设计从一开始就默认“项目方不会乱碰用户数据”，这个默认只要有一次不成立，用户的资产、交易数据裸奔就是迟早的事。
拆@dusk_foundation 主网RC版本的ZkKYC执行流程，让我停下来的正是这一层。它不是给隐私链多装一个合规模块，而是把“谁能看我的数据”直接变成“零知识电路能核验的硬规则”。用户开通审计权限前，规则先过原生Citadel模块的电路判断，身份凭证自持本地、交易状态靠Pedersen承诺加密，校验逻辑全链上公开。哪怕是项目方也没法绕过电路直接调取用户数据，零知识证明保证权限校验过程本身没被篡改，没到用户设定的授权范围，任何审计请求根本调不到明文数据。
#dusk 这个思路很像去银行开资产证明，柜员没法直接翻你全账户流水，只能按你申请的金额、用途开对应证明，多一点信息都拿不到。链上过去一直缺这道隐私确权的关卡，Dusk想补的不是匿名性有多强，是给隐私使用划一条用户可控的边界。
我也不会把它捧上天。用户弄丢本地KYC凭证就没法再开合规审计证明；零知识电路如果出逻辑bug，权限校验照样会出漏洞。真正要验证的不是叙事漂亮不漂亮，是真实RWA资产跑上去之后这套隐私约束扛不扛得住。
以后链上合规资产会越来越多，我更在意的不是它能不能做匿名交易，是谁能证明你的隐私只有你自己说了算@Dusk

#dusk $DUSK Kemarin pukul dua dini hari, saya nyaris tertidur di meja kerja rumah sewaan, membolak-balik whitepaper @Dusk_Foundation . Sudut meja baru terbuka setengah jam, es soda sudah habis semua, dan tetesan air yang mengembun di dinding gelas menetes ke alas mouse, membentuk noda cincin kecil berwarna lebih gelap. Dusk mengusung Privacy Layer1 yang menyasar skenario keuangan. Mekanisme konsensus Succinct Attestation karya mandirinya—kalau dibilang jujur, ini memang khusus untuk mengobati masalah lama yang sudah berkali-kali saya injak: para pemilik dana besar di rantai PoS mendominasi produksi blok, sumber acak mudah dimanipulasi, dan konfirmasi blok lambat. Klaimnya: finalitas deterministik dalam 3 detik, tahan serangan 51%, dan tidak akan membuat beberapa pemegang koin besar memegang kendali hak pembuatan blok. Kedengarannya memang tidak ada salahnya. Desentralisasi, keamanan, performa tinggi—tiga poin masalah yang sudah bertahun-tahun diperdebatkan industri. Katanya dia bisa semuanya? Tapi begitu saya membalik bagian pembangkitan seed untuk pemilihan acak, penulisannya sangat samar. Mereka hanya menulis, “dibangkitkan berdasarkan agregasi hash blok pendahulu.” Saya geser mouse ke samping, menatap layar dua detik tanpa gerak. Kalau performa acak pada undian node produksi blok bisa ditebak lebih dulu oleh segelintir node besar, bahkan disiasati lewat konspirasi, maka “randomness yang adil untuk memilih validator” itu jelas cuma kedok. Atribut desentralisasi node inti untuk privacy langsung dipotong setengah. Pertanyaan apakah seed acak ini bisa dimanipulasi atau dipalsukan melalui konspirasi—itu sudah dipahami oleh siapa pun yang berkutat di distributed consensus. Jauh lebih sulit daripada sekadar mempercepat kecepatan produksi blok. Kalau desain sumber acaknya ada celah, klaim performa tinggi dan ketahanan terhadap serangan jadi saling bertentangan, dan tidak bisa benar-benar diwujudkan. @Dusk_Foundation Di sini ada konflik inti: sebuah protokol yang katanya ingin melayani penyelesaian aset level institusi. Kalau logika verifikasi dari undian acak tidak dijelaskan sepenuhnya, maka kredibilitas konsensus SA pada dasarnya tetap perlu diuji lewat data dari operasi jangka panjang di mainnet, bukan sekadar klaim tertulis di whitepaper. Nilai jangka panjang $DUSK , dalam beberapa hal, benar-benar bergantung pada apakah mekanisme konsensus ini bisa berjalan dengan nyata. Saat kamu meneliti sebuah proyek, bagian mana dari whitepaper yang paling bikin kamu takut karena ditulis samar? Diskusikan di kolom komentar.

#dusk $DUSK Kemarin pukul dua dini hari, saya nyaris tertidur di meja kerja rumah sewaan, membolak-balik whitepaper @Dusk . Sudut meja baru terbuka setengah jam, es soda sudah habis semua, dan tetesan air yang mengembun di dinding gelas menetes ke alas mouse, membentuk noda cincin kecil berwarna lebih gelap.

Dusk mengusung Privacy Layer1 yang menyasar skenario keuangan. Mekanisme konsensus Succinct Attestation karya mandirinya—kalau dibilang jujur, ini memang khusus untuk mengobati masalah lama yang sudah berkali-kali saya injak: para pemilik dana besar di rantai PoS mendominasi produksi blok, sumber acak mudah dimanipulasi, dan konfirmasi blok lambat. Klaimnya: finalitas deterministik dalam 3 detik, tahan serangan 51%, dan tidak akan membuat beberapa pemegang koin besar memegang kendali hak pembuatan blok.

Kedengarannya memang tidak ada salahnya.

Desentralisasi, keamanan, performa tinggi—tiga poin masalah yang sudah bertahun-tahun diperdebatkan industri. Katanya dia bisa semuanya? Tapi begitu saya membalik bagian pembangkitan seed untuk pemilihan acak, penulisannya sangat samar. Mereka hanya menulis, “dibangkitkan berdasarkan agregasi hash blok pendahulu.” Saya geser mouse ke samping, menatap layar dua detik tanpa gerak. Kalau performa acak pada undian node produksi blok bisa ditebak lebih dulu oleh segelintir node besar, bahkan disiasati lewat konspirasi, maka “randomness yang adil untuk memilih validator” itu jelas cuma kedok. Atribut desentralisasi node inti untuk privacy langsung dipotong setengah. Pertanyaan apakah seed acak ini bisa dimanipulasi atau dipalsukan melalui konspirasi—itu sudah dipahami oleh siapa pun yang berkutat di distributed consensus. Jauh lebih sulit daripada sekadar mempercepat kecepatan produksi blok. Kalau desain sumber acaknya ada celah, klaim performa tinggi dan ketahanan terhadap serangan jadi saling bertentangan, dan tidak bisa benar-benar diwujudkan. @Dusk

Di sini ada konflik inti: sebuah protokol yang katanya ingin melayani penyelesaian aset level institusi. Kalau logika verifikasi dari undian acak tidak dijelaskan sepenuhnya, maka kredibilitas konsensus SA pada dasarnya tetap perlu diuji lewat data dari operasi jangka panjang di mainnet, bukan sekadar klaim tertulis di whitepaper.

Nilai jangka panjang $DUSK , dalam beberapa hal, benar-benar bergantung pada apakah mekanisme konsensus ini bisa berjalan dengan nyata.

Saat kamu meneliti sebuah proyek, bagian mana dari whitepaper yang paling bikin kamu takut karena ditulis samar? Diskusikan di kolom komentar.

Lihat terjemahan

#dusk $DUSK 昨晚刷新Dusk官网，导航栏全换了。

翻了快一年的旧入口消失得干干净净，我在"技术栈"和"开发者"两个板块之间来回切了四五次才找到节点文档。说实话有点恼火——但顺着新官网从底层协议一路往上捋，看完三个核心更新之后，我反而庆幸这一晚上没白费。

先说DuskEVM——这个我最想吐槽也最惊喜的。

我之前一直觉得Rusk虚拟机隐私性拉满，但原生Rust合约开发门槛太高。结果这次DuskEVM直接把我之前的抱怨堵回去了——它不是跨链桥，是内置了一个字节码转译器。什么意思？我把原来的Solidity合约丢进去，它自动转成符合PLONK电路约束的隐私执行代码，我压根不用管ZK底层。

实际操作更直接。我昨晚连测试网，拿一个之前的Swap合约试了下，从编译到部署花了12分钟。对比之前啃Rust写原生合约，效率差了不止一个量级。这个转译器是我今天最想安利的点。

Dusk Trade是第二个让我意外的。

它基于Phoenix zkUTXO架构——我看了半天才弄明白，你可以理解为每笔交易都是一张独立加密票据，只有持有密钥才能看到内容。没有公开Mempool，夹子机器人根本抢不了跑。同时内置了定向视图密钥接口，机构做市要过欧盟MiCA审计时，可以定向授权查看交易记录。合规和隐私，这次没二选一。

合规市场工作流直接把KYC、限售期编译进ZK证明里。交易上链时自动验证合规，人工审核直接省掉。

以前总说隐私和合规只能选一个。Dusk这套打完，二选一不存在了。

唯一的问题是——当初因为开发门槛太高放弃搭链上应用的，现在准备什么时候回来？@Dusk

Lihat terjemahan

#dusk $DUSK 前阵子冲Dusk的测试网激励，入金环节被弹了个资金来源验证，我当时都做好准备导半年的地址交易记录了——之前玩Zcash做同类合规证明，光传截图就折腾了20分钟，Gas烧了快0.1个币，还把我整个地址的持仓全露给验证方了，每次碰到这种要求都头大。结果我在Dusk钱包里点了三下，两分钟就过了验证，连我地址里剩多少测试币，验证方都没看到。

我之前对Dusk的认知就停留在“做隐私的公链”，甚至默认它和其他匿名链一样，为了隐私放弃可审计性，翻了快两小时Phoenix交易模型的Rust源码，翻到眼酸才搞明白它的设计是真的戳痛点。

它根本没做非黑即白的“全公开/全匿名”开关，而是在zk-SNARKs证明层做了可验证加密凭证（VEP）设计，用Plookup算法把单份证明体积压到了1KB以内。别的ZK隐私链做同类证明至少要生成10KB以上的证明，验证要等十几秒，它的链上验证只需要2毫秒：你要证明资金来自正规交易所，只需要针对这一笔入金生成定向证明，不需要暴露完整地址、总持仓、其他交易记录，甚至不用告诉对方你的收款地址是什么。我当时生成证明只花了0.0003DUSK的Gas，比普通转账还便宜，验证方直接在链上调合约就能验真伪，连我上传截图的步骤都省了。翻区块浏览器看，这笔交易里只有证明哈希，半分明文数据都没有。

之前所有隐私链都卡在“要隐私就没法合规，要合规就丢隐私”的死胡同，Dusk这套设计把隐私控制权完全交回给用户：需要藏交易时链上查不到任何明文，要做合规证明时只给对方看最少的必要信息，半分多余隐私都不用漏。
你们有没有过为了做链上认证，被迫暴露全部持仓的尴尬经历？@Dusk

Lihat terjemahan

#dusk $DUSK 老伙计深夜甩来两条60秒语音，语气跟当年喊我冲土狗一样急：Dusk主网上线，质押节点能跑了，隐私赛道头矿。

我心想跟Sui、Aptos那会儿差不多吧，装二进制挂着就行。结果三天通宵才啃明白。

第一天就卡壳。./dusk-node跑起来，ZK证明生成到87%必崩，终端吐一句"witness construction failed"，内存从4G顶到12G，风扇跟楼下夜宵摊抽油烟机似的。重装五次程序、重下三次快照，都没用。最后翻GitHub示例，一行注释小得差点漏过去："key expects BigInt, string will break witness construction."改完传参方式，重启，8秒证明生成。

静下心翻源码才懂。Dusk的隐私方案不是给EVM套层壳，而是Rusk这个原生隐私虚拟机直接把PLONK零知识证明电路、Poseidon哈希、BLS签名这些密码学组件内置进去。开发者写合约时不用手动处理加密逻辑，编译完就是零知识友好的WASM字节码。合约代码自动转成约束电路，多笔交易能递归聚合成一个批量证明，节点只验证明哈希，地址、金额全程不上链，但每笔交易的合规性都能被数学证明验证。

共识层是SBA（隔离拜占庭协议）。验证者至少要锁1000枚$DUSK ，每轮出块不仅要打包交易，还得附一份证明出块行为合法的ZK证明。Dusk的罚没分两种：软罚没针对漏块，会暂时移出共识并降低有效质押额；硬罚没针对作恶——出无效块罚没10%，双签或双块罚没20%，直接销毁。硬件方面，官方建议4核CPU、8GB内存起步。

跑了三周，收益没营销号吹得夸张。但跑通那晚机箱风扇安静下来，回头看三天值了，不是赚多少，是把一条新链的底子从头啃了一遍。@Dusk

#baby $BABY Kenyataan malam sebelumnya, saya melakukan satu hal: menguji skrip staking Babylon dengan UTXO yang dipatok di testnet saya sendiri. Saya ingin melihat bagaimana tepatnya ketiga cara keluar itu berjalan. Pertama, saya coba yang paling sederhana—setelah masa staking berakhir, hanya dengan tanda tangan saya sendiri untuk membuka kunci UTXO tersebut, lalu disiarkan ke testnet Bitcoin. Node lolos, transaksi terkemas. Tidak perlu ada persetujuan dari Finality Provider, tidak perlu Babylon chain online—tanda tangan saya sendiri sudah cukup. Waktu itu saya pikir, inilah rasa aman yang paling dasar: selama jaringan Bitcoin masih berjalan, staker bisa mengambil kembali uang mereka. Lalu saya coba cara kedua: simulasi kalau saya tidak ingin menunggu full masa staking, dan ingin keluar lebih cepat. Kali ini butuh tanda tangan saya sendiri, ditambah tanda tangan dari komite Covenant. Di sisi saya urus tanda tangannya mudah, sedangkan untuk pihak komite, saya mensimulasikan alur tanda tangan mereka. Setelah disiarkan, validasi node lolos, dan UTXO berhasil dibuka. Saya paham sekarang: komite hanya bertugas memverifikasi bahwa permintaan keluar lebih cepat ini sesuai aturan, tidak mengambil alih aset, dan tidak punya kendali. Saat mencoba yang ketiga, saya sempat buntu. Jalur slashing butuh tiga kunci: tanda tangan saya sendiri, tanda tangan EOTS Finality Provider, dan tanda tangan komite Covenant. Waktu itu saya berpikir: kenapa slashing masih harus melibatkan tanda tangan saya? Bukankah itu membuat saya ikut berpartisipasi dalam menghukum diri sendiri? Kemudian saya baru tahu alasannya setelah membaca laporan audit. Tanda tangan komite Covenant ternyata adalah tanda tangan adaptor—setelah dienkripsi, ia mengarah ke Finality Provider. Saya sudah menandatangani jalur slashing sebelumnya, tetapi tanda tangan ini dalam kondisi normal bersifat “terkunci”. Baru akan ter-dekripsi dan aktif jika FP menggunakan angka acak yang sama untuk menandatangani dua blok berbeda pada ketinggian (height) yang sama, sehingga kunci privat terekspos. Artinya, saya tidak perlu percaya siapa pun agar tidak berbuat jahat. Kalau FP berbuat jahat → ekspos kunci privat secara matematis → tanda tangan adaptor otomatis ter-dekripsi → jalur slashing terbuka. Saya tidak perlu administrator memutuskan “haruskah dihukum atau tidak”, dan tidak perlu persetujuan apa pun dari siapa pun. Saya sudah menguji ketiga cara keluar. Jalur mana yang dipilih tidak ditentukan oleh omongan orang—semuanya tergantung apakah kondisi yang ditetapkan dalam skrip terpenuhi. @babylonlabs_io

#baby $BABY Kenyataan malam sebelumnya, saya melakukan satu hal: menguji skrip staking Babylon dengan UTXO yang dipatok di testnet saya sendiri.

Saya ingin melihat bagaimana tepatnya ketiga cara keluar itu berjalan.

Pertama, saya coba yang paling sederhana—setelah masa staking berakhir, hanya dengan tanda tangan saya sendiri untuk membuka kunci UTXO tersebut, lalu disiarkan ke testnet Bitcoin. Node lolos, transaksi terkemas. Tidak perlu ada persetujuan dari Finality Provider, tidak perlu Babylon chain online—tanda tangan saya sendiri sudah cukup. Waktu itu saya pikir, inilah rasa aman yang paling dasar: selama jaringan Bitcoin masih berjalan, staker bisa mengambil kembali uang mereka.

Lalu saya coba cara kedua: simulasi kalau saya tidak ingin menunggu full masa staking, dan ingin keluar lebih cepat. Kali ini butuh tanda tangan saya sendiri, ditambah tanda tangan dari komite Covenant. Di sisi saya urus tanda tangannya mudah, sedangkan untuk pihak komite, saya mensimulasikan alur tanda tangan mereka. Setelah disiarkan, validasi node lolos, dan UTXO berhasil dibuka. Saya paham sekarang: komite hanya bertugas memverifikasi bahwa permintaan keluar lebih cepat ini sesuai aturan, tidak mengambil alih aset, dan tidak punya kendali.

Saat mencoba yang ketiga, saya sempat buntu. Jalur slashing butuh tiga kunci: tanda tangan saya sendiri, tanda tangan EOTS Finality Provider, dan tanda tangan komite Covenant. Waktu itu saya berpikir: kenapa slashing masih harus melibatkan tanda tangan saya? Bukankah itu membuat saya ikut berpartisipasi dalam menghukum diri sendiri?

Kemudian saya baru tahu alasannya setelah membaca laporan audit. Tanda tangan komite Covenant ternyata adalah tanda tangan adaptor—setelah dienkripsi, ia mengarah ke Finality Provider. Saya sudah menandatangani jalur slashing sebelumnya, tetapi tanda tangan ini dalam kondisi normal bersifat “terkunci”. Baru akan ter-dekripsi dan aktif jika FP menggunakan angka acak yang sama untuk menandatangani dua blok berbeda pada ketinggian (height) yang sama, sehingga kunci privat terekspos.

Artinya, saya tidak perlu percaya siapa pun agar tidak berbuat jahat. Kalau FP berbuat jahat → ekspos kunci privat secara matematis → tanda tangan adaptor otomatis ter-dekripsi → jalur slashing terbuka. Saya tidak perlu administrator memutuskan “haruskah dihukum atau tidak”, dan tidak perlu persetujuan apa pun dari siapa pun.

Saya sudah menguji ketiga cara keluar. Jalur mana yang dipilih tidak ditentukan oleh omongan orang—semuanya tergantung apakah kondisi yang ditetapkan dalam skrip terpenuhi.

@BabylonLabs_io

Beberapa waktu lalu saya melihat Babylon mengajukan proposal di komunitas Aave. Reaksi pertama saya adalah: apa ini lagi-lagi mau membuat versi “membungkus Bitcoin” seperti yang dulu? WBTC, cbBTC, dan sejenisnya pada dasarnya adalah menyerahkan BTC kepada pihak penitipan, lalu menerima pengganti dalam bentuk token ERC-20. Yang Anda lihat di Ethereum adalah “BTC”, tapi BTC aslinya ada di dompet pihak lain. Jika pihak penitipnya kabur, “BTC”-Anda pun tinggal angin. Jadi, awalnya saya menolak proposal Aave dari Babylon. Sampai saya membolak-balik dokumennya dan menyadari: saya ternyata benar-benar salah arah. vaultBTC Babylon sebenarnya bukan aset hasil pembungkusan. Itu adalah aset pencatatan internal yang pengirimannya dibatasi. 1 vaultBTC = 1 BTC, dan hanya boleh berinteraksi dengan kontrak Aave yang sudah disetujui. Anda tidak bisa mentransfernya ke orang lain, tidak bisa memakainya di protokol lain; Anda hanya bisa menggunakannya di Aave sebagai agunan. Bedanya di mana? Aset hasil pembungkusan itu “mengubah BTC menjadi ERC-20”. vaultBTC itu “mencatat satu transaksi di dalam kontrak Aave”. BTC sama sekali tidak lepas dari mainnet Bitcoin—BTC tersebut dikunci dalam skrip Taproot. Di sisi Aave, yang dilihat bukan BTC-nya sendiri, melainkan bukti kriptografis yang diajukan oleh protokol Babylon—membuktikan bahwa di dalam brankas itu memang terkunci jumlah BTC yang sesuai, dan tidak ada pihak yang bisa mengubahnya sepihak. Babylon men-deploy dua modul di Aave v4: Babylon Core Lending Spoke untuk menangani peminjaman, dan BTC Vault Swap Spoke untuk menyelesaikan transaksi setelah likuidasi. Setelah pengguna mengunci BTC ke vault TBV, adapter Aave akan mencetak (mint) vaultBTC dalam jumlah yang sama berdasarkan bukti kriptografis, lalu langsung memasoknya ke Core Spoke. Setelah itu, pengguna bisa meminjam USDC, USDT, atau WBTC di Aave. Saat pembayaran kembali (repayment), vaultBTC yang sesuai akan dihancurkan (burn), sehingga BTC dilepaskan. Dalam seluruh rangkaian ini, tidak ada satu pun pihak yang perlu “dipercaya”. Status BTC diverifikasi lewat bukti kriptografis, bukan lewat kata-kata manusia. vaultBTC tidak dapat dipindahtangankan; artinya, meskipun ada celah pada kontrak Aave, penyerang tidak bisa mengambil BTC Anda—BTC hanya bisa digunakan untuk menyelesaikan bagian agunan yang terkait dengan posisi Anda di dalam proses likuidasi. Baru di sini saya sadar: saya sebelumnya memikirkan masalahnya secara terbalik. Bukan “Babylon menerbitkan pengganti BTC di Ethereum”, melainkan “Babylon membuat BTC yang dikunci di mainnet Bitcoin menjadi dapat diverifikasi lewat bukti kriptografis di Ethereum”. Aset tidak bergerak, yang bergerak adalah buktinya. TVL Babylon sudah melebihi 56,853 BTC. Pemegang BTC akhirnya tidak perlu lagi memilih antara “mencari yield” dan “self-custody”. #BABY $BABY @babylonlabs_io #baby $BABY

Beberapa waktu lalu saya melihat Babylon mengajukan proposal di komunitas Aave. Reaksi pertama saya adalah: apa ini lagi-lagi mau membuat versi “membungkus Bitcoin” seperti yang dulu?

WBTC, cbBTC, dan sejenisnya pada dasarnya adalah menyerahkan BTC kepada pihak penitipan, lalu menerima pengganti dalam bentuk token ERC-20. Yang Anda lihat di Ethereum adalah “BTC”, tapi BTC aslinya ada di dompet pihak lain. Jika pihak penitipnya kabur, “BTC”-Anda pun tinggal angin.

Jadi, awalnya saya menolak proposal Aave dari Babylon. Sampai saya membolak-balik dokumennya dan menyadari: saya ternyata benar-benar salah arah.

vaultBTC Babylon sebenarnya bukan aset hasil pembungkusan. Itu adalah aset pencatatan internal yang pengirimannya dibatasi. 1 vaultBTC = 1 BTC, dan hanya boleh berinteraksi dengan kontrak Aave yang sudah disetujui. Anda tidak bisa mentransfernya ke orang lain, tidak bisa memakainya di protokol lain; Anda hanya bisa menggunakannya di Aave sebagai agunan.

Bedanya di mana? Aset hasil pembungkusan itu “mengubah BTC menjadi ERC-20”. vaultBTC itu “mencatat satu transaksi di dalam kontrak Aave”. BTC sama sekali tidak lepas dari mainnet Bitcoin—BTC tersebut dikunci dalam skrip Taproot. Di sisi Aave, yang dilihat bukan BTC-nya sendiri, melainkan bukti kriptografis yang diajukan oleh protokol Babylon—membuktikan bahwa di dalam brankas itu memang terkunci jumlah BTC yang sesuai, dan tidak ada pihak yang bisa mengubahnya sepihak.

Babylon men-deploy dua modul di Aave v4: Babylon Core Lending Spoke untuk menangani peminjaman, dan BTC Vault Swap Spoke untuk menyelesaikan transaksi setelah likuidasi. Setelah pengguna mengunci BTC ke vault TBV, adapter Aave akan mencetak (mint) vaultBTC dalam jumlah yang sama berdasarkan bukti kriptografis, lalu langsung memasoknya ke Core Spoke. Setelah itu, pengguna bisa meminjam USDC, USDT, atau WBTC di Aave. Saat pembayaran kembali (repayment), vaultBTC yang sesuai akan dihancurkan (burn), sehingga BTC dilepaskan.

Dalam seluruh rangkaian ini, tidak ada satu pun pihak yang perlu “dipercaya”. Status BTC diverifikasi lewat bukti kriptografis, bukan lewat kata-kata manusia. vaultBTC tidak dapat dipindahtangankan; artinya, meskipun ada celah pada kontrak Aave, penyerang tidak bisa mengambil BTC Anda—BTC hanya bisa digunakan untuk menyelesaikan bagian agunan yang terkait dengan posisi Anda di dalam proses likuidasi.

Baru di sini saya sadar: saya sebelumnya memikirkan masalahnya secara terbalik. Bukan “Babylon menerbitkan pengganti BTC di Ethereum”, melainkan “Babylon membuat BTC yang dikunci di mainnet Bitcoin menjadi dapat diverifikasi lewat bukti kriptografis di Ethereum”. Aset tidak bergerak, yang bergerak adalah buktinya.

TVL Babylon sudah melebihi 56,853 BTC. Pemegang BTC akhirnya tidak perlu lagi memilih antara “mencari yield” dan “self-custody”.

#BABY $BABY @BabylonLabs_io #baby $BABY

Saat dulu saya membaca skema ekspansi BTC, saya punya sebuah penilaian bawaan: masalah terbesar Bitcoin adalah terlalu sedikit fungsinya. Jadi, banyak proyek ekosistem BTC yang pertama kali memberi kesan kepada saya adalah upaya untuk menambah lebih banyak kegunaan bagi BTC. Namun setelah meneliti Babylon’s Trustless Bitcoin Vaults (TBV), saya menyadari bahwa pemahaman saya sebelumnya sedikit keliru. Masalah yang sesungguhnya bukanlah membuat agar BTC memiliki lebih banyak fungsi, melainkan bagaimana membuat Bitcoin tetap bisa ikut serta dengan aman dalam lebih banyak skenario tanpa memahami dunia eksternal. Perubahan cara pandang ini muncul dari satu detail yang saya lihat ketika meneliti desain Vault. Saat TBV membuat brankas (vault), para penyetor dan semua pihak yang terlibat terlebih dahulu mencantumkan seluruh kemungkinan jalur keluarnya BTC yang sah—jalur mana yang ditempuh untuk penebusan normal, jalur mana jika ada pihak yang menantang, dan jalur mana jika semuanya menjadi buntu. Setiap jalur digambar terlebih dahulu sebagai satu transaksi utuh, lalu setiap pihak menandatangani transaksi tersebut. Setelah itu, skrip Taproot mengodekan jalur-jalur tersebut menjadi leaf pengeluaran (spend) yang terpisah, dan barulah brankas aktif. Setelah diaktifkan, tidak ada pihak mana pun yang dapat menciptakan jalur pengeluaran baru. Ini berarti Vault bukan sekadar dompet untuk menyimpan BTC, melainkan sekumpulan aturan status. Kapan status boleh berubah, kondisi apa saja yang harus dipenuhi—semua harus diverifikasi sesuai logika yang telah ditetapkan. Logika-logika ini sudah ditulis ke dalam skrip saat pembuatan, dan setelahnya tidak ada siapa pun yang bisa memodifikasi. Pada akhirnya yang berubah adalah cara BTC berpartisipasi dalam dunia eksternal. Dulu saya mengira tantangan terbesar untuk ekspansi BTC adalah “kurangnya aplikasi”. Belakangan saya sadar masalah yang sesungguhnya adalah “bagaimana status eksternal dapat dikonfirmasi dengan andal”. Di sinilah Babylon menarik perhatian saya. TBV bukan hanya menambah satu pintu penggunaan BTC, melainkan mencoba membangun cara koneksi yang baru: membuat Bitcoin tetap mempertahankan basis keamanannya yang asli, sekaligus memungkinkan lebih banyak skenario on-chain agar memahami dan memanfaatkan keamanan tersebut. Bagi mereka yang telah lama memperhatikan BTC, fokus kompetisi di masa depan mungkin bukanlah siapa yang menciptakan lebih banyak variasi permainan, melainkan siapa yang bisa menyelesaikan masalah yang lebih mendasar: ketika aset yang paling mengutamakan keamanan memasuki dunia yang lebih kompleks, bagaimana aturan dapat menggantikan penilaian manusia? Inilah juga alasan saya memahami Babylon kembali. Bukan karena Babylon membuat BTC memiliki lebih banyak fungsi, melainkan mengubah cara BTC membangun hubungan kepercayaan dengan dunia eksternal. @babylonlabs_io #baby $BABY

Saat dulu saya membaca skema ekspansi BTC, saya punya sebuah penilaian bawaan: masalah terbesar Bitcoin adalah terlalu sedikit fungsinya.

Jadi, banyak proyek ekosistem BTC yang pertama kali memberi kesan kepada saya adalah upaya untuk menambah lebih banyak kegunaan bagi BTC. Namun setelah meneliti Babylon’s Trustless Bitcoin Vaults (TBV), saya menyadari bahwa pemahaman saya sebelumnya sedikit keliru.

Masalah yang sesungguhnya bukanlah membuat agar BTC memiliki lebih banyak fungsi, melainkan bagaimana membuat Bitcoin tetap bisa ikut serta dengan aman dalam lebih banyak skenario tanpa memahami dunia eksternal.

Perubahan cara pandang ini muncul dari satu detail yang saya lihat ketika meneliti desain Vault.

Saat TBV membuat brankas (vault), para penyetor dan semua pihak yang terlibat terlebih dahulu mencantumkan seluruh kemungkinan jalur keluarnya BTC yang sah—jalur mana yang ditempuh untuk penebusan normal, jalur mana jika ada pihak yang menantang, dan jalur mana jika semuanya menjadi buntu. Setiap jalur digambar terlebih dahulu sebagai satu transaksi utuh, lalu setiap pihak menandatangani transaksi tersebut. Setelah itu, skrip Taproot mengodekan jalur-jalur tersebut menjadi leaf pengeluaran (spend) yang terpisah, dan barulah brankas aktif. Setelah diaktifkan, tidak ada pihak mana pun yang dapat menciptakan jalur pengeluaran baru.

Ini berarti Vault bukan sekadar dompet untuk menyimpan BTC, melainkan sekumpulan aturan status. Kapan status boleh berubah, kondisi apa saja yang harus dipenuhi—semua harus diverifikasi sesuai logika yang telah ditetapkan. Logika-logika ini sudah ditulis ke dalam skrip saat pembuatan, dan setelahnya tidak ada siapa pun yang bisa memodifikasi.

Pada akhirnya yang berubah adalah cara BTC berpartisipasi dalam dunia eksternal.

Dulu saya mengira tantangan terbesar untuk ekspansi BTC adalah “kurangnya aplikasi”. Belakangan saya sadar masalah yang sesungguhnya adalah “bagaimana status eksternal dapat dikonfirmasi dengan andal”.

Di sinilah Babylon menarik perhatian saya. TBV bukan hanya menambah satu pintu penggunaan BTC, melainkan mencoba membangun cara koneksi yang baru: membuat Bitcoin tetap mempertahankan basis keamanannya yang asli, sekaligus memungkinkan lebih banyak skenario on-chain agar memahami dan memanfaatkan keamanan tersebut.

Bagi mereka yang telah lama memperhatikan BTC, fokus kompetisi di masa depan mungkin bukanlah siapa yang menciptakan lebih banyak variasi permainan, melainkan siapa yang bisa menyelesaikan masalah yang lebih mendasar: ketika aset yang paling mengutamakan keamanan memasuki dunia yang lebih kompleks, bagaimana aturan dapat menggantikan penilaian manusia?

Inilah juga alasan saya memahami Babylon kembali. Bukan karena Babylon membuat BTC memiliki lebih banyak fungsi, melainkan mengubah cara BTC membangun hubungan kepercayaan dengan dunia eksternal. @BabylonLabs_io #baby $BABY

Babylon Euphrates uji jaringan proses staking, sepenuhnya membalikkan pemahaman bawaan saya tentang staking BTC. Minggu lalu, saya mengamati dari dekat selama setengah jam hingga mendapatkan uji jaringan BTC. Setelah menyelesaikan seluruh proses staking, saya baru sadar: proses ini sama sekali tidak menempuh jalur lama “memindahkan aset ke kontrak kustodian”. Sebaliknya, aturan staking langsung dikompilasi ke dalam skrip Taproot Bitcoin pada custom leaf node. Dengan struktur MAST (Merkelized Abstract Syntax Tree), kondisi untuk unlock dipecah menjadi beberapa bagian logika tersembunyi. Sepanjang proses, BTC asli tidak pernah keluar dari jaringan Bitcoin. Inti mekanisme ini adalah desain khas Babylon bernama “anchoring notarization”. Setiap kali status staking berubah, akan dihasilkan bukti ZK-SNARK (zero-knowledge proof) yang terkompresi hingga di bawah 1KB. Melalui konsensus polling berbasis BABE, setelah konfirmasi multi-tanda 2/3 diverifikasi di jaringan node, bukti tersebut disinkronkan ke semua chain Cosmos dan EVM yang terhubung. Kontrak pada ekosistem eksternal sama sekali tidak menyentuh BTC asli; mereka hanya memverifikasi bukti notarization yang dihasilkan oleh Babylon. Pengguna hanya memegang bukti tersebut untuk langsung berpartisipasi dalam BTC yang menghasilkan imbal hasil di DeFi Cosmos atau Binance ZK Rollup, tanpa perlu menukarkan atau mengonversi token mapping kustodian apa pun. Seluruh logika verifikasi status dipaksakan oleh jaringan node Babylon; jika satu node bertindak curang, ia tidak akan bisa menghasilkan bukti yang sah. Sebelumnya, skema staking BTC di industri semuanya mengharuskan pengguna mentransfer aset ke kontrak kustodian pihak ketiga. Intinya, ini menyerahkan keamanan sepenuhnya kepada pihak proyek, dan risiko “meledak” tidak pernah bisa dihilangkan sepenuhnya. Sementara itu, desain Babylon ini memotong semua aspek kustodian dari lapisan terbawah, sehingga batas keamanan staking sepenuhnya “di-anchored” pada jaringan utama Bitcoin itu sendiri. Banyak orang menganggap bahwa pelepasan likuiditas BTC pasti harus dibawa lintas-chain. Namun Babylon menggunakan jalur notarization asli untuk menghindari jalan buntu tersebut, dengan mengekspor kemampuan keamanan lapisan dasar Bitcoin langsung ke seluruh ekosistem. Upgrade Euphrates ini adalah titik awal sesungguhnya ketika Bitcoin mulai mengekspor nilai ke luar@babylonlabs_io #baby $BABY

Babylon Euphrates uji jaringan proses staking, sepenuhnya membalikkan pemahaman bawaan saya tentang staking BTC.

Minggu lalu, saya mengamati dari dekat selama setengah jam hingga mendapatkan uji jaringan BTC. Setelah menyelesaikan seluruh proses staking, saya baru sadar: proses ini sama sekali tidak menempuh jalur lama “memindahkan aset ke kontrak kustodian”. Sebaliknya, aturan staking langsung dikompilasi ke dalam skrip Taproot Bitcoin pada custom leaf node. Dengan struktur MAST (Merkelized Abstract Syntax Tree), kondisi untuk unlock dipecah menjadi beberapa bagian logika tersembunyi. Sepanjang proses, BTC asli tidak pernah keluar dari jaringan Bitcoin.

Inti mekanisme ini adalah desain khas Babylon bernama “anchoring notarization”. Setiap kali status staking berubah, akan dihasilkan bukti ZK-SNARK (zero-knowledge proof) yang terkompresi hingga di bawah 1KB. Melalui konsensus polling berbasis BABE, setelah konfirmasi multi-tanda 2/3 diverifikasi di jaringan node, bukti tersebut disinkronkan ke semua chain Cosmos dan EVM yang terhubung.

Kontrak pada ekosistem eksternal sama sekali tidak menyentuh BTC asli; mereka hanya memverifikasi bukti notarization yang dihasilkan oleh Babylon. Pengguna hanya memegang bukti tersebut untuk langsung berpartisipasi dalam BTC yang menghasilkan imbal hasil di DeFi Cosmos atau Binance ZK Rollup, tanpa perlu menukarkan atau mengonversi token mapping kustodian apa pun. Seluruh logika verifikasi status dipaksakan oleh jaringan node Babylon; jika satu node bertindak curang, ia tidak akan bisa menghasilkan bukti yang sah.

Sebelumnya, skema staking BTC di industri semuanya mengharuskan pengguna mentransfer aset ke kontrak kustodian pihak ketiga. Intinya, ini menyerahkan keamanan sepenuhnya kepada pihak proyek, dan risiko “meledak” tidak pernah bisa dihilangkan sepenuhnya. Sementara itu, desain Babylon ini memotong semua aspek kustodian dari lapisan terbawah, sehingga batas keamanan staking sepenuhnya “di-anchored” pada jaringan utama Bitcoin itu sendiri.

Banyak orang menganggap bahwa pelepasan likuiditas BTC pasti harus dibawa lintas-chain. Namun Babylon menggunakan jalur notarization asli untuk menghindari jalan buntu tersebut, dengan mengekspor kemampuan keamanan lapisan dasar Bitcoin langsung ke seluruh ekosistem.

Upgrade Euphrates ini adalah titik awal sesungguhnya ketika Bitcoin mulai mengekspor nilai ke luar@BabylonLabs_io #baby $BABY

Ajukan satu pertanyaan: jika pihak kustodian wBTC mengalami masalah, aset dan laporan audit tidak langsung bisa dicocokkan. Pada insiden peretasan jembatan lintas-chain senilai 190 juta dolar AS, banyak institusi menempatkan kata “penghubung” dalam daftar hitam permanen. Bagi institusi, kepatuhan bukanlah nilai tambah—melainkan tiket masuk. Apa yang dilakukan Babylon TBV pada dasarnya adalah menerbitkan ulang “tiket masuk” tersebut. Bagaimana caranya? BTC tidak pernah keluar dari jaringan Bitcoin—BTC dikunci dalam output Taproot. Tidak ada bridging, tidak ada wrapping, dan tidak ada penanganan pihak ketiga mana pun. Auditor hanya perlu membuka penjelajah on-chain untuk melihat: aset masih berada di UTXO yang sama, lokasinya tidak berubah, dan jumlahnya tidak berkurang. Di antara brankas terjadi isolasi total: BTC kamu tidak tercampur dengan BTC orang lain. Tidak ada re-collateralization lagi, tidak ada dana pooled. Masalah pada pinjaman yang kamu ambil dari Aave akan berdampak pada posisi kamu di Aave, bukan pada BTC yang kamu kunci di jaringan Bitcoin. Yang dilihat auditor adalah: exposure risiko jelas, dapat ditelusuri, dan dapat diaudit. Semua operasi memiliki bukti kriptografi, bukan “kami menjamin” melainkan “pembuktian matematis”. Auditor ingin apa, on-chain langsung memberikannya; tidak perlu mencari siapa pun untuk menandatangani dan membubuhkan stempel. Dari penguncian BTC hingga pinjaman di Aave hingga penebusan akhir, setiap langkah terjadi di chain dan setiap langkah dapat diverifikasi secara independen. Ini bukan teori. BitGo sudah menjadi kustodian yang memenuhi syarat untuk Babylon. Kraken meluncurkan layanan staking bitcoin untuk Babylon. Ledger mengintegrasikan dukungan penandatanganan TBV. a16z berinvestasi 15 juta dolar AS. Babylon sudah melakukan staking lebih dari 56.000 BTC, dengan puncak TVL lebih dari 6 miliar dolar AS—angka-angka itu adalah suara institusi yang dibayar dengan uang sungguhan. Integrasi dengan Aave bahkan lebih krusial. Babylon telah mengajukan proposal ke forum tata kelola Aave, merencanakan integrasi native bitcoin collateral borrowing pada Aave V4. Pendiri Aave, Stani Kulechov, secara terbuka mendukung. VaultBTC yang diperkenalkan dalam proposal tersebut adalah aset pencatatan yang tidak dapat dialihkan; ia hanya bisa berinteraksi dengan kontrak Aave—auditor pasti langsung paham, benda ini tidak akan “lari-lari”. Dulu, institusi harus memilih salah satu antara “yield” dan “kepatuhan”. Sekarang tidak lagi. Ketika auditor bisa dengan tenang menandatangani laporan, ketika CFO bisa dengan tenang melakukan collateral, ketika 2 triliun dolar AS bitcoin pertama kali “dipakai” tanpa harus “dipindahkan”—pasar ini bukan lagi turunan dari DeFi, melainkan rekonstruksi DeFi itu sendiri. @babylonlabs_io #baby $BABY

Ajukan satu pertanyaan: jika pihak kustodian wBTC mengalami masalah, aset dan laporan audit tidak langsung bisa dicocokkan. Pada insiden peretasan jembatan lintas-chain senilai 190 juta dolar AS, banyak institusi menempatkan kata “penghubung” dalam daftar hitam permanen. Bagi institusi, kepatuhan bukanlah nilai tambah—melainkan tiket masuk.

Apa yang dilakukan Babylon TBV pada dasarnya adalah menerbitkan ulang “tiket masuk” tersebut.

Bagaimana caranya? BTC tidak pernah keluar dari jaringan Bitcoin—BTC dikunci dalam output Taproot. Tidak ada bridging, tidak ada wrapping, dan tidak ada penanganan pihak ketiga mana pun. Auditor hanya perlu membuka penjelajah on-chain untuk melihat: aset masih berada di UTXO yang sama, lokasinya tidak berubah, dan jumlahnya tidak berkurang.

Di antara brankas terjadi isolasi total: BTC kamu tidak tercampur dengan BTC orang lain. Tidak ada re-collateralization lagi, tidak ada dana pooled. Masalah pada pinjaman yang kamu ambil dari Aave akan berdampak pada posisi kamu di Aave, bukan pada BTC yang kamu kunci di jaringan Bitcoin. Yang dilihat auditor adalah: exposure risiko jelas, dapat ditelusuri, dan dapat diaudit.

Semua operasi memiliki bukti kriptografi, bukan “kami menjamin” melainkan “pembuktian matematis”. Auditor ingin apa, on-chain langsung memberikannya; tidak perlu mencari siapa pun untuk menandatangani dan membubuhkan stempel. Dari penguncian BTC hingga pinjaman di Aave hingga penebusan akhir, setiap langkah terjadi di chain dan setiap langkah dapat diverifikasi secara independen.

Ini bukan teori. BitGo sudah menjadi kustodian yang memenuhi syarat untuk Babylon. Kraken meluncurkan layanan staking bitcoin untuk Babylon. Ledger mengintegrasikan dukungan penandatanganan TBV. a16z berinvestasi 15 juta dolar AS. Babylon sudah melakukan staking lebih dari 56.000 BTC, dengan puncak TVL lebih dari 6 miliar dolar AS—angka-angka itu adalah suara institusi yang dibayar dengan uang sungguhan.

Integrasi dengan Aave bahkan lebih krusial. Babylon telah mengajukan proposal ke forum tata kelola Aave, merencanakan integrasi native bitcoin collateral borrowing pada Aave V4. Pendiri Aave, Stani Kulechov, secara terbuka mendukung. VaultBTC yang diperkenalkan dalam proposal tersebut adalah aset pencatatan yang tidak dapat dialihkan; ia hanya bisa berinteraksi dengan kontrak Aave—auditor pasti langsung paham, benda ini tidak akan “lari-lari”.

Dulu, institusi harus memilih salah satu antara “yield” dan “kepatuhan”. Sekarang tidak lagi. Ketika auditor bisa dengan tenang menandatangani laporan, ketika CFO bisa dengan tenang melakukan collateral, ketika 2 triliun dolar AS bitcoin pertama kali “dipakai” tanpa harus “dipindahkan”—pasar ini bukan lagi turunan dari DeFi, melainkan rekonstruksi DeFi itu sendiri.
@BabylonLabs_io #baby $BABY

Kapitalisasi pasar Bitcoin sudah melampaui 2 triliun, namun di DeFi yang benar-benar dimanfaatkan tidak sampai 1%. Bukan karena para holder tidak mau untung, tapi karena skema yang ada pada dasarnya membuatmu menjawab soal pilihan ganda: “BTC saya harus diserahkan untuk dikendalikan oleh siapa?” @babylonlabs_io Babylon’s Trustless Bitcoin Vaults (TBV) berbeda. Ia menghapus “soal pilihan ganda” itu. Pertama, BTC kamu dari awal sampai akhir tidak pernah keluar dari jaringan Bitcoin. Tidak melewati jembatan, tidak dienkapsulasi, dan tidak memberi pihak ketiga apa pun. BTC dikunci dalam sebuah skrip Taproot yang kamu ikut tanda tangani. Saat vault dibuat, semua jalur pengambilan yang sah sudah dipraprogram dan ditandatangani. Setelah pembentukan selesai, tidak ada siapa pun yang bisa mengubah atau menambah jalur penarikan secara sepihak. Ada poin penting yang patut dijelaskan. Skrip Taproot yang dipakai TBV berbeda secara mendasar dari multisig tradisional: ia lebih fleksibel untuk time-lock dan skrip berbasis kondisi. Tanpa harus mempublikasikan logika yang rumit, syarat pengambilan dapat langsung dikodekan ke dalam jaringan Bitcoin. Artinya, kamu tidak perlu mempercayai sekelompok penanda tangan untuk “tidak berbuat jahat”; kamu hanya perlu mempercayai skrip itu sendiri—karena skrip tersebut terkunci secara matematis. Kedua, kontrak di sisi ETH hanya bertugas membaca status vault, tidak bersentuhan dengan aset BTC aslinya. Saat penarikan dilakukan, sistem menggunakan oracle untuk meneruskan peristiwa penebusan di Ethereum ke jaringan Bitcoin, lalu memverifikasi bahwa kejadian itu benar-benar terjadi melalui bukti pengetahuan nol (zero-knowledge proof). Setelah verifikasi lolos, barulah BTC dilepaskan. Ada juga detail yang mudah terlewat: bahkan jika oracle diserang dan seseorang mengirim permintaan penarikan palsu yang berbahaya, vault tetap tidak akan menjalankan transaksi tersebut. Karena jalur penarikan itu tidak ada dalam daftar jalur yang sudah kamu tandatangani sebelumnya—skripnya pun tidak mengenalinya. Paling penting, setiap vault benar-benar terisolasi satu sama lain: tidak bisa ditaruh ulang (re-pledge), dan tidak bisa disalahgunakan. Bahkan jika terdapat celah pada protokol DeFi lapisan atas, BTC kamu tetap aman terkunci dalam skrip di mainnet Bitcoin itu dan tidak terpengaruh. Mekanisme ini mengubah “kepercayaan kepada manusia” menjadi “kepercayaan kepada kriptografi”. Kamu tidak perlu yakin tim proyek tidak akan kabur, karena tim proyek sama sekali tidak punya kemampuan untuk memindahkan BTC kamu. Kamu juga tidak perlu memastikan para validator tidak berbuat jahat, karena saksi jahat pun tidak bisa menghabiskan koinmu setelah mendapat akses. Selain itu, Ledger baru-baru ini mengintegrasikan fitur Clear Signing. Saat menandatangani transaksi TBV, perangkat keras menampilkan langsung di layar setiap tujuan aliran dana dan isi operasinya. Risiko blind signing benar-benar diputus total. #baby $BABY

Kapitalisasi pasar Bitcoin sudah melampaui 2 triliun, namun di DeFi yang benar-benar dimanfaatkan tidak sampai 1%. Bukan karena para holder tidak mau untung, tapi karena skema yang ada pada dasarnya membuatmu menjawab soal pilihan ganda: “BTC saya harus diserahkan untuk dikendalikan oleh siapa?” @BabylonLabs_io

Babylon’s Trustless Bitcoin Vaults (TBV) berbeda. Ia menghapus “soal pilihan ganda” itu.

Pertama, BTC kamu dari awal sampai akhir tidak pernah keluar dari jaringan Bitcoin. Tidak melewati jembatan, tidak dienkapsulasi, dan tidak memberi pihak ketiga apa pun. BTC dikunci dalam sebuah skrip Taproot yang kamu ikut tanda tangani. Saat vault dibuat, semua jalur pengambilan yang sah sudah dipraprogram dan ditandatangani. Setelah pembentukan selesai, tidak ada siapa pun yang bisa mengubah atau menambah jalur penarikan secara sepihak.

Ada poin penting yang patut dijelaskan. Skrip Taproot yang dipakai TBV berbeda secara mendasar dari multisig tradisional: ia lebih fleksibel untuk time-lock dan skrip berbasis kondisi. Tanpa harus mempublikasikan logika yang rumit, syarat pengambilan dapat langsung dikodekan ke dalam jaringan Bitcoin. Artinya, kamu tidak perlu mempercayai sekelompok penanda tangan untuk “tidak berbuat jahat”; kamu hanya perlu mempercayai skrip itu sendiri—karena skrip tersebut terkunci secara matematis.

Kedua, kontrak di sisi ETH hanya bertugas membaca status vault, tidak bersentuhan dengan aset BTC aslinya. Saat penarikan dilakukan, sistem menggunakan oracle untuk meneruskan peristiwa penebusan di Ethereum ke jaringan Bitcoin, lalu memverifikasi bahwa kejadian itu benar-benar terjadi melalui bukti pengetahuan nol (zero-knowledge proof). Setelah verifikasi lolos, barulah BTC dilepaskan.

Ada juga detail yang mudah terlewat: bahkan jika oracle diserang dan seseorang mengirim permintaan penarikan palsu yang berbahaya, vault tetap tidak akan menjalankan transaksi tersebut. Karena jalur penarikan itu tidak ada dalam daftar jalur yang sudah kamu tandatangani sebelumnya—skripnya pun tidak mengenalinya.

Paling penting, setiap vault benar-benar terisolasi satu sama lain: tidak bisa ditaruh ulang (re-pledge), dan tidak bisa disalahgunakan. Bahkan jika terdapat celah pada protokol DeFi lapisan atas, BTC kamu tetap aman terkunci dalam skrip di mainnet Bitcoin itu dan tidak terpengaruh.

Mekanisme ini mengubah “kepercayaan kepada manusia” menjadi “kepercayaan kepada kriptografi”. Kamu tidak perlu yakin tim proyek tidak akan kabur, karena tim proyek sama sekali tidak punya kemampuan untuk memindahkan BTC kamu. Kamu juga tidak perlu memastikan para validator tidak berbuat jahat, karena saksi jahat pun tidak bisa menghabiskan koinmu setelah mendapat akses.

Selain itu, Ledger baru-baru ini mengintegrasikan fitur Clear Signing. Saat menandatangani transaksi TBV, perangkat keras menampilkan langsung di layar setiap tujuan aliran dana dan isi operasinya. Risiko blind signing benar-benar diputus total.
#baby $BABY

Saya kali ini menguji @OpenGradient—yang macet bukanlah jawabannya, melainkan “hari berikutnya”. Malam sebelumnya, saya membuat alur pengingat on-chain yang sangat kecil: membiarkan AI membaca beberapa interaksi kontrak, lalu memeriksa apakah ada indikasi lonjakan volume yang abnormal. Hasil putaran pertama berjalan mulus, sampai hampir saya menuliskannya sebagai pengalaman penggunaan biasa OpenGradient Chat. Tapi pada malam hari kedua, saat saya bersiap memeriksa ulang, saya tiba-tiba menemukan masalah yang lebih nyata: jika saya tidak membuka halaman secara aktif, apakah prosesnya benar-benar berjalan tepat waktu? Setelah selesai, apakah kontrak atau aplikasi selanjutnya bisa langsung membaca hasilnya? Saya mengubah selang waktu menjadi lebih singkat, mensimulasikan beberapa putaran pemeriksaan berurutan. Yang paling tidak nyaman adalah, putaran pertama hanya memberi “indikasi adanya anomali”, lalu pada putaran kedua setelah ditambahkan interaksi baru barulah menjadi “perlu pengingat”. Jika di antara dua putaran itu tidak ada hasil antara yang bisa dibaca, langkah berikutnya akhirnya hanya bisa disambungkan secara manual oleh manusia. Pada saat itulah saya sadar: banyak alat AI menyelesaikan masalah “kamu bertanya, saya menjawab”, tetapi Agent on-chain yang sesungguhnya membutuhkan “berjalan sendiri sesuai jadwal, dan setelah selesai bisa diteruskan ke langkah berikutnya”. Kalau tidak, skor risiko hari ini, pengingat besok, penyesuaian strategi lusa—semuanya terlihat seperti satu alur, padahal kenyataannya hanya beberapa cuplikan layar percakapan. Kemudian saya melihat desain penjadwalan OpenGradient, dan barulah saya paham: ini bukan sekadar menambahkan timer. Tugas harus dipicu oleh jaringan, hasilnya harus bisa dibaca oleh alur berikutnya, dan biayanya serta catatan eksekusinya harus selaras. Detail ini tidak terlihat mencolok, tapi detail itulah yang menentukan apakah AI hanya asisten sementara, atau bisa menjadi komponen eksekusi yang masuk ke bisnis on-chain. Terutama dalam skenario tanpa pengawasan manusia—kalau putus sekali saja, setelahnya bisa semuanya salah. #opg Itulah alasan saya kembali meninjau $OPG . Bukan karena keramaian jawaban sekali jalan, melainkan karena biaya yang terus berjalan di balik eksekusi, penyerahan hasil, dan insentif jaringan. Kalau AI ke depannya ingin melakukan pembaruan untuk risk control, peringatan on-chain, atau penyeimbangan ulang strategi, yang paling ditakuti bukanlah satu kali jawaban yang tidak rapi, melainkan saat seharusnya memeriksa tidak memeriksa, atau setelah memeriksa tidak ada yang bisa mengonfirmasi apakah benar-benar sudah dikerjakan atau tidak. Uji coba ini membuat saya menilai OPG dengan lebih serius. Aplikasi AI yang benar-benar native bukan memindahkan manusia menjauh dari kotak input, melainkan memastikan bahwa ketika manusia tidak menatap, sistem tetap bisa meneruskan langkah yang seharusnya terjadi. #OPG $OPG @OpenGradient #opg $OPG

Saya kali ini menguji @OpenGradient—yang macet bukanlah jawabannya, melainkan “hari berikutnya”.

Malam sebelumnya, saya membuat alur pengingat on-chain yang sangat kecil: membiarkan AI membaca beberapa interaksi kontrak, lalu memeriksa apakah ada indikasi lonjakan volume yang abnormal. Hasil putaran pertama berjalan mulus, sampai hampir saya menuliskannya sebagai pengalaman penggunaan biasa OpenGradient Chat. Tapi pada malam hari kedua, saat saya bersiap memeriksa ulang, saya tiba-tiba menemukan masalah yang lebih nyata: jika saya tidak membuka halaman secara aktif, apakah prosesnya benar-benar berjalan tepat waktu? Setelah selesai, apakah kontrak atau aplikasi selanjutnya bisa langsung membaca hasilnya?

Saya mengubah selang waktu menjadi lebih singkat, mensimulasikan beberapa putaran pemeriksaan berurutan. Yang paling tidak nyaman adalah, putaran pertama hanya memberi “indikasi adanya anomali”, lalu pada putaran kedua setelah ditambahkan interaksi baru barulah menjadi “perlu pengingat”. Jika di antara dua putaran itu tidak ada hasil antara yang bisa dibaca, langkah berikutnya akhirnya hanya bisa disambungkan secara manual oleh manusia. Pada saat itulah saya sadar: banyak alat AI menyelesaikan masalah “kamu bertanya, saya menjawab”, tetapi Agent on-chain yang sesungguhnya membutuhkan “berjalan sendiri sesuai jadwal, dan setelah selesai bisa diteruskan ke langkah berikutnya”. Kalau tidak, skor risiko hari ini, pengingat besok, penyesuaian strategi lusa—semuanya terlihat seperti satu alur, padahal kenyataannya hanya beberapa cuplikan layar percakapan.

Kemudian saya melihat desain penjadwalan OpenGradient, dan barulah saya paham: ini bukan sekadar menambahkan timer. Tugas harus dipicu oleh jaringan, hasilnya harus bisa dibaca oleh alur berikutnya, dan biayanya serta catatan eksekusinya harus selaras. Detail ini tidak terlihat mencolok, tapi detail itulah yang menentukan apakah AI hanya asisten sementara, atau bisa menjadi komponen eksekusi yang masuk ke bisnis on-chain. Terutama dalam skenario tanpa pengawasan manusia—kalau putus sekali saja, setelahnya bisa semuanya salah. #opg

Itulah alasan saya kembali meninjau $OPG . Bukan karena keramaian jawaban sekali jalan, melainkan karena biaya yang terus berjalan di balik eksekusi, penyerahan hasil, dan insentif jaringan. Kalau AI ke depannya ingin melakukan pembaruan untuk risk control, peringatan on-chain, atau penyeimbangan ulang strategi, yang paling ditakuti bukanlah satu kali jawaban yang tidak rapi, melainkan saat seharusnya memeriksa tidak memeriksa, atau setelah memeriksa tidak ada yang bisa mengonfirmasi apakah benar-benar sudah dikerjakan atau tidak.

Uji coba ini membuat saya menilai OPG dengan lebih serius. Aplikasi AI yang benar-benar native bukan memindahkan manusia menjauh dari kotak input, melainkan memastikan bahwa ketika manusia tidak menatap, sistem tetap bisa meneruskan langkah yang seharusnya terjadi. #OPG $OPG @OpenGradient #opg $OPG

OPG-0,88%

1. Sensasi sepak bola paling ekstrem: sensasi mengetahui skrip tak terlihat “waktu tambahan” lebih dulu! Saat semua orang bertaruh mengikuti pola normal 90 menit, yakin sebuah tim bisa dengan mantap mengamankan kemenangan, kamu justru peka melihat bahwa wasit, karena durasi VAR yang terlalu lama di paruh pertama, secara bawah sadar akan memberi waktu tambahan yang sangat panjang—lebih dari 6 menit—di babak kedua. Dengan tegas memprediksi bahwa pihak yang unggul karena stamina sudah terkuras akan dibobol di menit-menit akhir oleh lawan lewat umpan panjang dan crossing yang sembrono, seolah tanpa konsekuensi. Sudut pandang layaknya “Tuhan” yang mampu menembus “variabel waktu” di balik “psikologi wasit” ini benar-benar membuat merinding! Ayo cepat gabung #BinancePickAndWin

Saat saya selesai membaca dokumentasi OpenGradient, terutama bab arsitektur HACA, barulah saya sadar kalau ternyata saya terlalu menyimpang. Awalnya saya terseret oleh “super node”, hingga otak saya otomatis membuat bagan alur: beli kartu grafis → pasang Ubuntu → ikat wallet → staking → tunggu tugas → terima uang. Sampai saya melihat HACA membagi node menjadi Inference Node dan Full Node, barulah saya menyadari bahwa ini bukan satu mesin yang mengerjakan semuanya. Inference Node menjalankan inferensi model, sedangkan Full Node bertugas memverifikasi attestation TEE, proof ZKML, atau hasil Vanilla—“cepat menjalankan” hanyalah dasar, sedangkan yang paling inti adalah “setelah selesai, mampu membuktikan diri bersih dan bisa dipercaya”. Pemahaman ini membuat laporan pendapatan saya harus dihitung ulang sepenuhnya. Dulu saya hanya menghitung “sewa GPU per hari dikurangi biaya listrik”, tapi pada kenyataannya yang menentukan pendapatan bersih adalah tiga variabel dinamis: jumlah pemanggilan yang efektif, apakah catatan verifikasi stabil, dan seberapa tinggi tingkat mesin menganggur (idle). Saya membuat model kasar menggunakan data testnet: ketika pemanggilan rata-rata hanya 50 kali per hari, pendapatan bulanan sekitar 30 dolar, bahkan biaya listrik pun bisa menutup kerugian. Hanya ketika jumlah pemanggilan stabil di atas 200 kali, dan tingkat kegagalan verifikasi di bawah 2%, barulah pendapatan bersih bisa menjadi positif. Yang juga menyadarkan saya adalah Staking Rewards. Resmi memang menuliskan rilis jangka panjang 10%, tapi dulu saya menganggapnya sebagai “APR untuk penahanan dana”. Setelah saya baca detail aturannya, 10% itu adalah insentif kolektif untuk seluruh jaringan node, dan pembagian bobotnya bergantung pada kualitas layanan—jumlah pemanggilan yang efektif, tingkat verifikasi yang berhasil, dan durasi online semuanya diberi bobot. Itu bukan annual rate yang tetap, melainkan seperti bonus kinerja. Jadi, saya melihat $OPG sebagai tiga hal: jaminan (deposit) untuk ikut jaringan, perantara Gas untuk membayar pemanggilan, dan pintu masuk untuk mendapatkan reward—bukan sekadar “bukti bisa rebahan menghasilkan”. Berdasarkan pemahaman ini, saya mengubah fokus optimasi dari menumpuk perangkat keras menjadi memilih beban (load). Saya lebih dulu melakukan cache untuk model frekuensi tinggi seperti Llama-3, agar tiap tugas tidak perlu mengunduh ulang yang menyeret bandwidth. Pemantauan saya hanya melihat empat garis merah: latensi respons (dipotong jika di atas 3 detik), utilisasi GPU (di bawah 60% berarti menganggur), frekuensi terputus (dropout), serta tingkat kegagalan saat mengirim bukti (proof). Jika biaya listrik lebih dari 0,8 yuan per kWh, saya tidak menyalakan perangkat 24 jam—saya hanya menjalankannya pada jam puncak. Jadi, artikel ini tidak punya “kunci kekayaan”. Kesimpulan sebenarnya saya adalah: node OPG punya peluang, tetapi peluang itu milik orang yang punya disiplin operasional, bukan hanya orang yang paham beli koin. Perangkat keras hanya tiket masuk; ambang sebenarnya adalah pemantauan, optimasi, dan pemulihan saat terjadi gangguan. @OpenGradient #opg $OPG

Saat saya selesai membaca dokumentasi OpenGradient, terutama bab arsitektur HACA, barulah saya sadar kalau ternyata saya terlalu menyimpang.

Awalnya saya terseret oleh “super node”, hingga otak saya otomatis membuat bagan alur: beli kartu grafis → pasang Ubuntu → ikat wallet → staking → tunggu tugas → terima uang. Sampai saya melihat HACA membagi node menjadi Inference Node dan Full Node, barulah saya menyadari bahwa ini bukan satu mesin yang mengerjakan semuanya. Inference Node menjalankan inferensi model, sedangkan Full Node bertugas memverifikasi attestation TEE, proof ZKML, atau hasil Vanilla—“cepat menjalankan” hanyalah dasar, sedangkan yang paling inti adalah “setelah selesai, mampu membuktikan diri bersih dan bisa dipercaya”.

Pemahaman ini membuat laporan pendapatan saya harus dihitung ulang sepenuhnya. Dulu saya hanya menghitung “sewa GPU per hari dikurangi biaya listrik”, tapi pada kenyataannya yang menentukan pendapatan bersih adalah tiga variabel dinamis: jumlah pemanggilan yang efektif, apakah catatan verifikasi stabil, dan seberapa tinggi tingkat mesin menganggur (idle). Saya membuat model kasar menggunakan data testnet: ketika pemanggilan rata-rata hanya 50 kali per hari, pendapatan bulanan sekitar 30 dolar, bahkan biaya listrik pun bisa menutup kerugian. Hanya ketika jumlah pemanggilan stabil di atas 200 kali, dan tingkat kegagalan verifikasi di bawah 2%, barulah pendapatan bersih bisa menjadi positif.

Yang juga menyadarkan saya adalah Staking Rewards. Resmi memang menuliskan rilis jangka panjang 10%, tapi dulu saya menganggapnya sebagai “APR untuk penahanan dana”. Setelah saya baca detail aturannya, 10% itu adalah insentif kolektif untuk seluruh jaringan node, dan pembagian bobotnya bergantung pada kualitas layanan—jumlah pemanggilan yang efektif, tingkat verifikasi yang berhasil, dan durasi online semuanya diberi bobot. Itu bukan annual rate yang tetap, melainkan seperti bonus kinerja. Jadi, saya melihat $OPG sebagai tiga hal: jaminan (deposit) untuk ikut jaringan, perantara Gas untuk membayar pemanggilan, dan pintu masuk untuk mendapatkan reward—bukan sekadar “bukti bisa rebahan menghasilkan”.

Berdasarkan pemahaman ini, saya mengubah fokus optimasi dari menumpuk perangkat keras menjadi memilih beban (load). Saya lebih dulu melakukan cache untuk model frekuensi tinggi seperti Llama-3, agar tiap tugas tidak perlu mengunduh ulang yang menyeret bandwidth. Pemantauan saya hanya melihat empat garis merah: latensi respons (dipotong jika di atas 3 detik), utilisasi GPU (di bawah 60% berarti menganggur), frekuensi terputus (dropout), serta tingkat kegagalan saat mengirim bukti (proof). Jika biaya listrik lebih dari 0,8 yuan per kWh, saya tidak menyalakan perangkat 24 jam—saya hanya menjalankannya pada jam puncak.

Jadi, artikel ini tidak punya “kunci kekayaan”. Kesimpulan sebenarnya saya adalah: node OPG punya peluang, tetapi peluang itu milik orang yang punya disiplin operasional, bukan hanya orang yang paham beli koin. Perangkat keras hanya tiket masuk; ambang sebenarnya adalah pemantauan, optimasi, dan pemulihan saat terjadi gangguan.

@OpenGradient #opg $OPG

OPG-0,88%