<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by 0xh on Medium]]></title>
        <description><![CDATA[Stories by 0xh on Medium]]></description>
        <link>https://medium.com/@0xh?source=rss-988d1eca1cd1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*bAxysarF5Uz055U0vA82wQ.png</url>
            <title>Stories by 0xh on Medium</title>
            <link>https://medium.com/@0xh?source=rss-988d1eca1cd1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:34:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@0xh/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Fixing crypto UX at the cryptographic layer]]></title>
            <link>https://medium.com/@0xh/fixing-crypto-ux-at-the-cryptographic-layer-833f1441ca21?source=rss-988d1eca1cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/833f1441ca21</guid>
            <category><![CDATA[ethereum]]></category>
            <category><![CDATA[bitcoin]]></category>
            <category><![CDATA[cryptocurrency]]></category>
            <category><![CDATA[cryptography]]></category>
            <category><![CDATA[passkey]]></category>
            <dc:creator><![CDATA[0xh]]></dc:creator>
            <pubDate>Sun, 04 Jan 2026 16:03:02 GMT</pubDate>
            <atom:updated>2026-01-04T16:03:02.009Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*aHbz-Z18GGXWfC5T" /><figcaption>Created with IA</figcaption></figure><p>There’s a lot of <a href="https://dappworks.com/why-did-satoshi-decide-to-use-secp256k1-instead-of-secp256r1/">speculation</a> that <strong>Satoshi </strong>avoided <strong>secp256r1 </strong>/ <strong>P-256</strong> due to distrust of <strong>NIST</strong>/<strong>NSA </strong>(and the cypherpunk zeitgeist of the time), but there is no conclusive proof. There’s also a version attributed to <strong>Mike Hearn </strong>suggesting the choice was simply pragmatic (“<a href="https://www.reddit.com/r/btc/comments/79hjwc/i_didnt_find_anything_to_recommend_a_curve_type/">it was available</a>”). As storytelling, it works; as a fact, it’s better treated as a hypothesis.</p><blockquote><em>I didn’t find anything to recommend a curve type so I just… picked one.</em></blockquote><p>What <em>does</em> matter today isn’t whether <strong>P-256</strong> is “better” or “worse.” It’s that modern authentication standardized on P-256, while crypto standardized on <strong>secp256k1 </strong>— and that split has very real consequences for usability, cost, and adoption.</p><h3>A foundational choice that shaped an ecosystem</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/767/0*OnnuLekedkdjvFJ0" /><figcaption>Created with IA</figcaption></figure><p>Early crypto systems needed a concrete signing primitive. <strong>secp256k1 </strong>became the default, and over time that decision hardened into infrastructure: wallets, hardware devices, libraries, tooling, and eventually the EVM itself.</p><p><a href="https://www.linkedin.com/company/ethereum/">Ethereum</a> didn’t just <em>use</em> <strong>secp256k1 </strong>— it optimized for it. The <em>ecrecover </em>precompile made k1 verification cheap and ubiquitous, reinforcing the curve as a first-class citizen at the protocol level.</p><blockquote><em>This wasn’t ideology. It was engineering gravity.</em></blockquote><h3>Seed phrases as “UX” by necessity</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/0*VU9ZwhVfd1XPUDI6" /><figcaption>Created with IA</figcaption></figure><p>On top of that cryptographic foundation, self-custody converged on seed phrases. They are elegant, deterministic, and offline-safe — but brutally unforgiving to humans.</p><p>For more than a decade, crypto UX implicitly asked users to manage catastrophic failure modes themselves. Not because designers didn’t care, but because <strong>the cryptographic stack offered no better primitive.</strong></p><blockquote><em>Seed phrases weren’t chosen because they were user-friendly. They were chosen because they fit the available infrastructure.</em></blockquote><h3>The web moved on with passkeys</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/770/0*8mXnRLeWaXfPJLgM" /><figcaption>Created with IA</figcaption></figure><p>Meanwhile, the web solved authentication differently.</p><p>Passkeys (<strong>WebAuthn </strong>/ <strong>FIDO</strong>) abstract asymmetric cryptography behind secure hardware and familiar gestures. Face ID, Touch ID, platform authenticators — under the hood, most of this runs on<strong> P-256</strong> (<strong>secp256r1</strong>).</p><p>The result: phishing resistance, hardware binding, seamless recovery across devices — and no mental model of keys required.</p><blockquote><em>The web didn’t abandon cryptography. It made it invisible.</em></blockquote><h3>Where Web3 hits the real wall</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/773/0*-gheDYhdPC5ADGwd" /><figcaption>Created with IA</figcaption></figure><p>When Web3 tries to adopt that UX, it immediately hits a hard boundary. Passkeys produce P-256 signatures. The EVM is optimized for <strong>secp256k1</strong>.</p><p>Without native support, verifying P-256 signatures on-chain is expensive and complex. This isn’t a product flaw or a missing SDK — it’s a<strong> protocol-level mismatch.</strong></p><p>As the <a href="https://ethereum-magicians.org/t/eip-7212-precompiled-for-secp256r1-curve-support/14789/122">RIP-7212 discussions</a> make clear, this isn’t about adding “one more curve.” It’s about enabling a class of authentication that already won everywhere else.</p><h3>RIP-7212: a pragmatic protocol translator</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/772/0*5kP9iT7K1x4mkHPw" /><figcaption>Created with IA</figcaption></figure><p><strong>RIP-7212</strong> proposes a precompile for verifying <strong>secp256r1 </strong>(P-256) signatures, initially targeting rollups and L2s.</p><p>Conceptually, it acts as a translator: taking a dominant WebAuthn primitive and making it cheap, predictable, and safe to verify inside the EVM. This dramatically lowers the cost of passkey-based smart accounts and removes the need for convoluted cryptographic workarounds.</p><blockquote><em>As highlighted in the </em><a href="https://ethereum-magicians.org/t/eip-7212-precompiled-for-secp256r1-curve-support/14789/122"><em>Ethereum Magicians thread</em></a><em>, the goal was never ideology — it was practical interoperability with modern authentication.</em></blockquote><h3>Update: P-256 is coming to Ethereum mainnet</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/0*aQPaXNB7GAqIJIJS" /><figcaption>Created with IA</figcaption></figure><p>This story now has a concrete turning point.</p><p><strong>EIP-7951</strong>, which builds on the same motivation as<strong> RIP-7212</strong> but focuses on L1-grade hardening and stricter validation, has been agreed for inclusion in the <strong>Fusaka hard fork</strong> (<a href="https://github.com/ethereum/pm/issues/1569">ACDE #241</a>). Gas repricing is still under evaluation (devnet-3), but the architectural decision is made.</p><p>This marks a shift from “proposal” to protocol reality.</p><blockquote><em>The takeaway is simple: if you want real “Face ID self-custody,” the bottleneck was never superficial UX. It was missing cryptographic infrastructure — and that infrastructure is now landing at the base layer.</em></blockquote><h3>Conclusion</h3><p>Crypto UX didn’t fail because users couldn’t understand it. It stalled because the underlying cryptographic infrastructure lagged behind how authentication evolved on the web.</p><p>For years, seed phrases weren’t a design choice — they were a constraint imposed by the primitives available at the protocol layer. Meanwhile, passkeys quietly became the global standard for secure, hardware-backed authentication, built on P-256 and invisible to end users.</p><p>With <strong>RIP-7212</strong> and now <strong>EIP-7951</strong> confirmed for inclusion in the Fusaka hard fork, that mismatch is finally being addressed. This isn’t about adding convenience or polishing interfaces. It’s about aligning Ethereum’s base-layer capabilities with the authentication models the rest of the world already uses.</p><p>If this transition holds, self-custody no longer has to feel like an exception to modern UX. It can become a default — secure, familiar, and cryptographically sound — without asking users to become key managers.</p><blockquote><em>The real shift isn’t “Face ID wallets.” It’s crypto infrastructure finally catching up with human reality.</em></blockquote><h3>Resources</h3><ul><li><a href="https://eips.ethereum.org/EIPS/eip-7951">EIP-7951: Precompile for secp256r1 Curve Support</a></li><li><a href="https://satyvm.medium.com/what-is-rip-7212-b101c805ff90">What is RIP-7212?: A Precompile for secp256r1 Curve Support</a></li><li><a href="https://dappworks.com/why-did-satoshi-decide-to-use-secp256k1-instead-of-secp256r1/">Why did Satoshi decide to use secp256k1 instead of secp256r1?</a></li><li><a href="https://www.reddit.com/r/btc/comments/79hjwc/i_didnt_find_anything_to_recommend_a_curve_type/">Satoshi Nakamoto on secp256k1 in email to Mike Hearn</a></li><li><a href="https://ethereum-magicians.org/t/eip-7212-precompiled-for-secp256r1-curve-support/14789/122">EIP-7212: Precompiled for secp256r1 Curve Support</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=833f1441ca21" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Del Seed Phrase al Face ID]]></title>
            <link>https://medium.com/@0xh/del-seed-phrase-al-face-id-a538ca573c01?source=rss-988d1eca1cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/a538ca573c01</guid>
            <category><![CDATA[crypto-wallet]]></category>
            <category><![CDATA[porto]]></category>
            <category><![CDATA[passkey]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[coinbase]]></category>
            <dc:creator><![CDATA[0xh]]></dc:creator>
            <pubDate>Sun, 21 Dec 2025 17:01:10 GMT</pubDate>
            <atom:updated>2025-12-21T17:01:10.038Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*bHQzoMxscpkG-jKC" /><figcaption>La historia de cómo crypto finalmente decidió ser usable</figcaption></figure><h3>La Evolución de la Autocustodia en Ethereum</h3><p>Durante más de una década, la autocustodia en Ethereum se apoyó en EOAs, seed phrases y modelos de seguridad diseñados para resistir ataques criptográficos, pero indiferentes a la experiencia humana. El resultado fue un sistema correcto en lo técnico, pero frágil en lo operativo y prácticamente inaccesible para usuarios no especializados. Este artículo analiza el cambio de paradigma que hoy comienza a consolidarse: cuentas que dejan de ser una clave y pasan a comportarse como software, <strong>autenticación basada en passkeys</strong> y hardware seguro, mecanismos de recuperación social on-chain y abstracciones que eliminan gas, firmas y complejidad del flujo del usuario. No se trata de un rediseño superficial ni de “mejor UX”, sino de una reconfiguración profunda de cómo se conciben identidad, seguridad y experiencia en sistemas descentralizados.</p><h3>La UX de Crypto estos años</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*sOt-U34ie9abXej2" /></figure><p>Imagina que vas al banco y el gerente te dice: “<em>Escribe estas 12 palabras en papel. Si las pierdes, pierdes todo tu dinero para siempre”</em>. Si alguien las ve, te lo roban todo. No hay botón de ‘<em>olvidé mi contraseña</em>’. ¿Suena bien? Te irías corriendo, ¿verdad?</p><p>Pues así es exactamente como funcionan las criptomonedas en 2025. Durante más de una década, hemos pedido a la gente que guarde seed phrases en papel, metal, o donde sea. Y luego nos preguntamos por qué crypto no despega masivamente.</p><p>La respuesta es obvia: <strong>la UX es terrible</strong>. No es que la gente sea “tech-illiterate”. Es que construimos productos imposibles de usar.</p><p>Pero las cosas están cambiando. Account Abstraction y Passkeys están reescribiendo las reglas del juego. Y no es ciencia ficción: es tecnología que probablemente ya usas todos los días sin saberlo.</p><h3>EOA: El Método Tradicional</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*2n9BoFN66z64zEvT" /></figure><p>Una <strong>EOA </strong>(Externally Owned Account) es el tipo de cuenta que usas en Ethereum desde 2015. Es simple: un par de llaves criptográficas.</p><p><strong>Cómo funciona:</strong></p><ul><li>Una clave privada = tu cuenta</li><li>Si pierdes la clave → Game Over</li><li>Si alguien la obtiene → Game Over</li><li>Responsabilidad 100% tuya</li></ul><p><strong>Ventajas:</strong></p><ul><li>Autocustodia real</li><li>Nadie más tiene control</li><li>Descentralización pura</li></ul><p><strong>Desventajas:</strong></p><ul><li>UX terrible</li><li>Ansiedad constante</li><li>No escala para mainstream</li></ul><p>Funcionó para early adopters porque somos masoquistas técnicos. Para tu abuela, es una pesadilla.</p><p>El pitch de “<em>sé tu propio banco</em>” suena genial hasta que te das cuenta de que ser tu propio banco significa ser también tu propio equipo de seguridad, tu propio soporte técnico, y tu propio seguro de depósitos. Sin vacaciones.</p><h3>Account Abstraction: Cuando Tu Cuenta Puede Pensar</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*Eg0OJ9Anr1VfmOpU" /></figure><p>Aquí es donde<strong> Account Abstraction</strong> cambia todo. La idea es revolucionaria en su simplicidad: ¿y si tu “cuenta” no fuera solo un par de llaves, sino un programa completo?</p><p>Piénsalo así: una EOA es como una caja fuerte con una sola llave. Un Smart Account es como un sistema de seguridad inteligente con múltiples formas de acceso, reglas personalizables, y backups automáticos.</p><p><strong>Con Account Abstraction, tu cuenta puede:</strong></p><ul><li><strong>Múltiples métodos de autenticación</strong>: No solo una clave privada. Face ID, huellas dactilares, hardware keys, lo que quieras. Y no es uno o el otro: puedes tener varios como backup.</li><li><strong>Social recovery</strong>: Configura tu cuenta para que 3 de 5 amigos puedan ayudarte a recuperar acceso si pierdes tu dispositivo. Es como tener guardianes, pero on-chain y transparente.</li><li><strong>Límites de gasto automáticos</strong>: “No permitas transacciones mayores a $1000 sin confirmación adicional.” Tu cuenta ejecuta las reglas automáticamente.</li><li><strong>Pagar gas en cualquier token</strong>: ¿No tienes ETH? No hay problema. Paga en USDC, DAI, o lo que tengas. Un “paymaster” paga el ETH por ti.</li><li><strong>Batching de transacciones:</strong> Aprueba + intercambia en una sola operación. Interactúa con 10 contratos en una sola firma.</li></ul><p>Es pasar de un Nokia 3310 a un iPhone. Ambos son teléfonos, pero uno claramente evolucionó. Y lo mejor: ERC-4337 ya está productivo. No es <em>vaporware</em>. Es real y ya funciona!</p><h3>La Evolución de la Autenticación Web3</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*W0Ro_Bi3okyvpzdl" /></figure><p>Hagamos un viaje rápido por la historia de cómo hemos intentado resolver este problema:</p><h4>2015–2022: EOA Tradicional</h4><p><em>“Aquí tienes 12 palabras aleatorias. Cuídalas con tu vida.”</em></p><p>Funcionó para los nerds porque disfrutábamos la complejidad. Era como un badge de honor tener 3 copias de tu seed phrase en diferentes continentes.</p><h4>2020–2023: OAuth/Social Login</h4><p><em>“¿Y si simplemente… usas Google?”</em></p><p>UX increíble. Cero fricción. Un problema: no es autocustodia. Un servidor tiene tu clave. Si ese servidor tiene un mal día, adiós fondos.</p><h4>2022–2024: MPC (Multi-Party Computation)</h4><p><em>“Dividamos la clave en pedazos y distribuyámosla entre múltiples servidores.”</em></p><p>Mejor que custodia centralizada. La clave nunca se reconstruye. Pero aún requieres confiar en esos servidores. ¿Quién los opera? ¿Pueden coludirse?</p><h4>2024-Presente: Passkeys</h4><p>Magia suficientemente avanzada disfrazada de tecnología.</p><p>Autocustodia real + UX familiar + respaldo automático. El santo grial.</p><h3>Passkeys: Magia Suficientemente Avanzada</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*qyWktWEf7hX9iMIe" /></figure><p>Passkeys son el estándar WebAuthn/FIDO2 que probablemente ya usas:</p><ul><li>Desbloquear tu iPhone con Face ID</li><li>Iniciar sesión en Google sin contraseña</li><li>Apple Pay / Google Pay</li></ul><h4>Cómo funcionan</h4><p><strong>Cuando creas una passkey:</strong></p><ol><li>Tu dispositivo genera un par de llaves P-256</li><li>La clave privada se guarda en en hardware seguro del dispositivo (Secure Enclave/TPM)</li><li>Esta clave NUNCA sale de ese hardware</li><li>La clave pública se registra on-chain en la smart account</li></ol><p><strong>Cuando firmas una transacción:</strong></p><ol><li>La app dice: “Firma este mensaje”</li><li>Escaneas tu cara/huella</li><li>El chip firma el mensaje (la clave nunca sale)</li><li>La firma se verifica on-chain</li></ol><h4>Por qué es revolucionario</h4><ul><li><strong>Autocustodia real:</strong> Tu clave vive en hardware especializado diseñado para proteger secretos. Es como tener un mini-HSM en tu bolsillo.</li><li><strong>UX familiar:</strong> Es literalmente igual que desbloquear tu teléfono. Tu abuela puede hacer esto.</li><li><strong>Respaldo automático:</strong> Si tu passkey está sincronizada con iCloud o Google, perder tu dispositivo no es el fin del mundo. Compras un nuevo teléfono, restauras, y tus passkeys están ahí.</li><li><strong>Anti-phishing nativo:</strong> Las passkeys están vinculadas al dominio donde se crearon. No puedes ser engañado.</li></ul><blockquote><em>Passkeys es la combinación perfecta: seguridad militar + UX de consumidor + autocustodia real.</em></blockquote><h3>EOA vs Passkeys: La Diferencia es BRUTAL</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*ymC1HDPtFgpsEiw3" /></figure><p>Pongamos las cosas en perspectiva con una comparación directa:</p><h4>EOA Tradicional</h4><ul><li><strong>Qué guardas</strong>: 12–24 palabras en papel/metal</li><li><strong>Autenticación</strong>: Copiar/pegar seed phrase o usar hardware wallet</li><li><strong>Si pierdes el dispositivo</strong>: Necesitas el papel de respaldo</li><li><strong>Seguridad</strong>: Depende 100% de ti y tus precauciones</li><li><strong>UX</strong>: 2/5 estrellas (siendo generosos)</li><li><strong>Recovery</strong>: Solo con la seed phrase física</li><li><strong>Portabilidad</strong>: Llevas el papel o lo memorizas (mala idea)</li></ul><h4>Passkeys + Smart Account</h4><ul><li><strong>Qué guardas</strong>: Nada físico (está en el chip de tu dispositivo)</li><li><strong>Autenticación</strong>: Face ID o Touch ID</li><li><strong>Si pierdes el dispositivo</strong>: Restauras desde iCloud/Google</li><li><strong>Seguridad</strong>: Chip de seguridad de grado militar</li><li><strong>UX</strong>: 5/5 estrellas (igual que apps normales)</li><li><strong>Recovery</strong>: Social recovery on-chain + respaldo cloud</li><li><strong>Portabilidad</strong>: Automática vía sincronización cloud</li></ul><p>Es como comparar enviar cartas por correo postal vs WhatsApp. Técnicamente ambos “funcionan”, pero uno es claramente superior en todos los aspectos que importan.</p><h3>Los Desafíos Técnicos (Por Qué No Todos Lo Usan Ya)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*pta2xQqZvSrMjRwR" /></figure><p>Ok, si es tan genial, ¿por qué no lo están usando todos?, porque hay desafíos técnicos reales que se están resolviendo ahora mismo:</p><h4>1. Curvas Elípticas: P-256 vs secp256k1</h4><ul><li><strong>El problema</strong>: Ethereum usa secp256k1 para firmas. Passkeys usan P-256. Son incompatibles.</li><li><strong>La solución</strong>: Verificar firmas P-256 on-chain. El problema es que es computacionalmente costoso en el EVM actual.</li><li><strong>El costo del gas</strong>: ~150–200k gas por verificación (vs ~3k para secp256k1).</li><li><strong>El futuro</strong>: RIP-7212 propone agregar P-256 como precompile nativo, reduciendo el costo a ~3k gas también.</li></ul><h4>2. Portabilidad: El Problema de rpId</h4><ul><li><strong>El problema</strong>: Las passkeys están vinculadas al dominio donde se crean (rpId = “<a href="http://app.example.com/">app.example.com</a>”). Si cambias de wallet provider, no puedes llevarte tu passkey.</li><li><strong>El impacto</strong>: Vendor lock-in. Usas la wallet de Coinbase, estás casado con Coinbase.</li><li><strong>Soluciones en exploración</strong>: Esquemas de wrapping que abstraen el rpId, estándares para portabilidad cross-domain y delegación de autenticación.</li></ul><p>Aún no hay consenso, pero se está trabajando activamente.</p><h4>3. Recovery: Qué Pasa Si Pierdes Todo</h4><ul><li>El escenario: Pierdes tu teléfono. Tu casa se quema (con tus backups). Tu cuenta de iCloud es hackeada.</li><li>La necesidad: Social recovery como red de seguridad final.</li></ul><p>Implementaciones actuales:</p><ul><li><strong>Safe</strong>: Guardianes on-chain que pueden activar recovery</li><li><strong>Argent</strong>: Contactos de confianza + límite de tiempo</li><li><strong>Custom</strong>: Tu propio smart contract con tus reglas</li></ul><blockquote><em>El desafío es balancear seguridad (no muy fácil de atacar) vs usabilidad (no muy complicado de usar).</em></blockquote><h4>4. Estandarización: ERC-7579</h4><ul><li><strong>El problema</strong>: Cada implementación de smart account tiene su propia interfaz.</li><li><strong>El impacto</strong>: Fragmentación del ecosistema. Los módulos no son portables entre wallets.</li><li><strong>La solución</strong>: ERC-7579 define interfaces estándar para módulos, plugins, y hooks.</li><li><strong>El estado</strong>: Adoptación todavía temprana. Safe lo está implementando. Otros siguen.</li></ul><p>Estos desafíos son reales, pero no son insuperables. De hecho, muchos ya están siendo resueltos en producción.</p><h3>Solución #1: Porto (Ithaca/Paradigm)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*vm1V7Ipcrj3gfV5U" /></figure><p><strong>Porto </strong>es la implementación de <strong>Ithaca </strong>(con respaldo de <strong>Paradigm</strong>) que pone énfasis en la solidez técnica.</p><h4>Lo Bueno</h4><ul><li><strong>SDK production-ready</strong>: Documentación completa, ejemplos funcionales, TypeScript types. Puedes empezar a construir hoy mismo.</li><li><strong>Session keys</strong>: Implementación elegante de session keys para gaming y apps que necesitan firmas frecuentes sin confirmaciones constantes.</li><li><strong>Arquitectura modular</strong>: Separation of concerns bien pensada. Validator, executor, y fallback handler como componentes independientes.</li><li><strong>Open source (parcial)</strong>: El core es open source. Puedes auditar el código, entender cómo funciona, proponer mejoras.</li></ul><h4>Los Trade-offs</h4><ul><li><strong>Requiere relay propio</strong>: Porto opera su propio bundler y paymaster. No puedes usar infraestructura independiente fácilmente. Es como tener un BMW: excelente ingeniería, pero estás casado con el ecosistema BMW.</li><li><strong>No sigue ERC-7579</strong>: Tiene su propia arquitectura de plugins. Los módulos no son portables a otras implementaciones ERC-7579.</li><li><strong>Dependencia de infraestructura</strong>: Si Porto decide cambiar su modelo de negocio, subir precios, o simplemente cerrar, tienes un problema.</li></ul><h4>Veredicto</h4><p><strong>Porto es técnicamente excelente</strong> para equipos que quieren la mejor ingeniería y no les importa depender de infraestructura específica. Es la opción de “alto rendimiento con compromiso de ecosistema”.</p><p>Si estás construyendo una app crítica y valoras soporte de primera, Porto es sólido. Si valoras independencia y portabilidad, mira otras opciones.</p><h3>Solución #2: Base Account (Coinbase)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*x3E9IpG7tM5bAK9R" /></figure><p><strong>Base Account </strong>es la apuesta de <a href="https://www.linkedin.com/company/coinbase/">Coinbase</a> en smart accounts. Y tienen una ventaja masiva: recursos de una empresa pública + años de experiencia en UX de crypto.</p><h4>Lo Increíble</h4><ul><li><strong>UX incomparable</strong>: Seriamente, es la mejor UX del mercado. Onboarding en 30 segundos. One-tap payments. Gasless transactions. Es lo que todos deberíamos aspirar a construir.</li><li><strong>Multi-chain desde día 1</strong>: Funciona en 9+ chains. Deploys tu account en todas con la misma dirección. Magic.</li><li><strong>Integración con Coinbase</strong>: Si usas Coinbase (y millones lo hacen), la transición es seamless. Es como Apple: el ecosistema cerrado funciona INCREÍBLEMENTE bien.</li><li><strong>Gasless por default</strong>: Coinbase subsidiza el gas. Los usuarios ni siquiera saben que están pagando comisiones. Es la UX que crypto necesita.</li></ul><h4>El Problema Mayor</h4><ul><li><strong>No es open source</strong>: El código no está disponible. No puedes auditarlo. No puedes self-hostear. No puedes modificarlo.</li><li><strong>Vendor lock-in total</strong>: Tu cuenta depende de infraestructura de Coinbase. Si Coinbase decide que no les gustas, tienen control efectivo de tus fondos. Sí, técnicamente es self-custody. En práctica, Coinbase tiene mucho poder.</li><li><strong>rpId locked</strong>: Tu passkey está vinculada a dominios de Coinbase. No puedes migrar a otra wallet.</li><li><strong>Contra el ethos de crypto</strong>: Crypto se construyó sobre transparencia, auditabilidad, y resistencia a censura. Base Account sacrifica eso por UX.</li></ul><h4>Veredicto</h4><p><strong>Base Account</strong> es<strong> Hotel California</strong>: puedes entrar, pero no puedes salir.</p><p>La UX es perfecta. Pero pagas el precio en dependencia. Es ideal para usuarios mainstream que no son puristas de descentralización. Para builders que quieren mantener opciones abiertas, es problemático.</p><p>La pregunta es: ¿estamos dispuestos a sacrificar open-source por UX? ¿O podemos tener ambos?</p><h3>Solución #3: ZKnox crypto-lib (Smooth)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*xP697FIeoSrkVe_P" /></figure><p><strong>ZKnox </strong>es el enfoque de Smooth: no te dan un producto completo, te dan las herramientas para construir el tuyo.</p><h4>Lo Poderoso</h4><ul><li><strong>100% open source (MIT)</strong>: Todo el código está disponible. Auditable. Modificable. Sin sorpresas.</li><li><strong>Primitivas criptográficas optimizadas</strong>: Verificación P-256, WebAuthn parsing, todo optimizado al máximo. Ellos hicieron el trabajo duro de cripto.</li><li><strong>Verificación P-256 eficiente</strong>: ~150k gas con su implementación optimizada. No es tan barato como un precompile, pero es usable.</li><li><strong>Building blocks, no producto</strong>: Te da librerías, contratos, y herramientas. Tú decides cómo combinarlas.</li></ul><h4>Los Desafíos</h4><ul><li><strong>No es un producto completo</strong>: No hay wallet lista para usar. No hay UI. No hay backend. Es código. Tienes que construir encima.</li><li><strong>Requiere expertise técnico</strong>: Necesitas entender Solidity, WebAuthn, y arquitectura de smart accounts. No es plug-and-play.</li><li><strong>Tú eres responsable de todo</strong>: Seguridad, UX, infraestructura, mantenimiento. La libertad viene con responsabilidad.</li><li><strong>Sin soporte comercial</strong>: Es open source comunitario. No hay equipo de soporte esperando tu ticket.</li></ul><h3>Veredicto</h3><p><strong>ZKnox </strong>es <strong>Linux</strong>: poderoso, flexible, requiere expertise. Es perfecto para equipos técnicos que quieren control total y están dispuestos a construir. No es para equipos que quieren una solución lista para usar. Si valoras transparencia y control sobre conveniencia, ZKnox es tu base. Si quieres algo que funcione out-of-the-box, necesitas más que esto.</p><h3>Análisis Comparativo: La Verdad Incómoda</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*7oEQbnkCDwUHAHhK" /></figure><p>Pongamos todo en una tabla para ver los trade-offs claramente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/774/0*5KKPeGgxHYSc511p" /></figure><h4>La Oportunidad Que Nadie Ha Capturado</h4><p>Ninguna implementación tiene todo:</p><ul><li>Open source + vendor neutral</li><li>UX comparable a Base</li><li>Self-hostable + portabilidad</li><li>Compatible con ERC-7579</li><li>Multi-chain desde día 1</li></ul><p>El mercado está esperando a alguien que combine lo mejor de los tres:</p><ul><li>La ingeniería sólida de Porto</li><li>La UX incomparable de Base</li><li>La transparencia total de ZKnox</li></ul><blockquote><em>Quien logre eso, gana.</em></blockquote><h3>Lo Que Ya Logramos (2023–2025)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*HXggAsNnTZnLGyII" /></figure><p>Antes de enfocarnos en lo que falta, celebremos lo que ya funciona:</p><h4>ERC-4337 en Producción ✓</h4><p>No es experimental. No es beta. Está VIVO:</p><ul><li>Bundlers operando en mainnet</li><li>Paymasters subsidiando gas</li><li>Miles de smart accounts activas</li><li>Auditorías completadas</li></ul><h4>Social Recovery Funcional ✓</h4><p>Safe y Argent tienen implementaciones probadas en batalla:</p><ul><li>Millones de dólares protegidos</li><li>Múltiples recoveries exitosos documentados</li><li>UI que realmente funciona</li></ul><h4>Gasless Transactions Reales ✓</h4><p>Usuarios interactuando con DeFi sin saber que están pagando gas:</p><ul><li>Paymasters en producción</li><li>Subsidios por proyectos</li><li>Pago en ERC-20</li></ul><h4>Batching de Transacciones ✓</h4><p>Una firma, múltiples operaciones:</p><ul><li>Approve + Swap en una tx</li><li>Deploy + Configure + Fund</li><li>Atomic multi-step workflows</li></ul><h4>Session Keys para Gaming ✓</h4><p>Juegos blockchain con UX digna:</p><ul><li>Firma una vez, juega por horas</li><li>Sin confirmaciones constantes</li><li>Límites configurables</li></ul><h4>Passkeys Llegando al Ecosistema ✓</h4><p>Ya no es teoría:</p><ul><li>Porto en producción</li><li>Base Account adoptándose</li><li>Más implementaciones en camino</li></ul><blockquote><em>El progreso en 2 años ha sido masivo. No estamos empezando de cero. Las bases están construidas.</em></blockquote><h3>Lo Que Falta (Los Próximos 12–18 Meses)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*arJJb8L7oKoL1Jag" /></figure><p>Ahora, qué necesitamos hacer para escalar esto a mainstream:</p><h4>Técnico</h4><ul><li><strong>RIP-7212: P-256 Precompile</strong>: Reducir verificación P-256 de ~150k gas a ~3k. Esto hace passkeys económicamente viables para uso frecuente. Sin esto, estamos limitados.</li><li><strong>Resolver portabilidad de rpId</strong>: Los usuarios necesitan poder cambiar de wallet sin perder acceso. Esquemas de wrapping, estándares de delegación, o arquitecturas creativas. Esto es crítico para evitar monopolios.</li><li><strong>Más adopción de ERC-7579</strong>: Estandarizar interfaces de módulos para que el ecosistema sea componible. Necesitamos que Safe, Argent, y otros grandes players adopten el estándar.</li></ul><h4>Adopción</h4><ul><li><strong>Wallets mainstream con passkeys</strong>: Necesitamos que MetaMask, Rainbow, Rabby, y otros grandes agreguen soporte. Actualmente es demasiado nicho.</li><li><strong>Educación de usuarios y developers</strong>: La mayoría de devs no entienden Account Abstraction. Los usuarios no saben que existe. Necesitamos contenido, tutoriales, workshops.</li><li><strong>Más competencia (monopolios = malos)</strong>: Actualmente Base Account tiene la mejor UX pero es closed source. Necesitamos alternativas open-source competitivas. La competencia mejora a todos.</li></ul><h4>Infraestructura</h4><ul><li><strong>Bundlers descentralizados</strong>: Actualmente dependemos de bundlers centralizados. Necesitamos un mempool descentralizado de UserOperations.</li><li><strong>Paymasters como servicio</strong>: Servicios como Pimlico existen, pero necesitamos más. Y necesitamos estándares para que sean intercambiables.</li><li><strong>Tooling de desarrollo</strong>: SDKs mejores, debuggers, testnets específicos, simuladores. Hacer que construir smart accounts sea tan fácil como construir contratos normales.</li></ul><p>Nada de esto es imposible. De hecho, todo está en progreso. Solo necesitamos coordinación y ejecución.</p><h3>Predicciones 2026–2027</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*rU4GCGLT1-7doDnE" /></figure><p>Basándonos en el momentum actual, aquí están mis predicciones para los próximos 12–24 meses:</p><h4>Passkeys Serán el Default (No Experimental)</h4><p>Para finales de 2026, crear una wallet con passkeys será tan común como conectar MetaMask hoy. Los tutoriales empezarán con “escanea tu cara” en lugar de “escribe estas 12 palabras”.</p><h4>1–2 Implementaciones Se Volverán Dominantes</h4><p>El mercado se consolidará. Probablemente un player closed-source (Base o similar) para mainstream, y uno open-source para builders y puristas. Como iOS vs Android.</p><h4>El Problema de rpId Se Resolverá</h4><p>Ya sea por estándares, wrapping schemes, o arquitecturas creativas, encontraremos una forma de hacer passkeys portables. Es demasiado importante para no resolverse.</p><h4>RIP-7212 Se Activará (o Algo Equivalente)</h4><p>El costo de P-256 bajará dramáticamente. Ya sea por precompile nativo o por optimizaciones de L2s. Esto desbloqueará casos de uso que hoy son demasiado caros.</p><h4>Tu Abuela Usará DeFi Sin Saberlo</h4><p>Apps mainstream adoptarán smart accounts en el backend. Los usuarios interactuarán con blockchain sin saber que lo están haciendo. Como usar Google sin entender TCP/IP.</p><h4>Frameworks de Desarrollo Madurarán</h4><p>SDKs tipo “create-smart-account-app” existirán. Pluggable modules para session keys, social recovery, etc. Construir un smart account será más fácil que construir un contrato ERC-20.</p><h4>Multi-Chain Será la Norma</h4><p>Tu smart account existirá en todas las chains simultáneamente. Una firma, deploys en 10 chains. Chain abstraction será real.</p><p><strong>No es ciencia ficción. Es ingeniería con fecha de entrega.</strong></p><blockquote><em>Las piezas están en el tablero. Solo necesitamos que alguien haga los movimientos correctos.</em></blockquote><h3>La Visión: El Mundo Que Queremos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*y-hkelSziWnLORUC" /></figure><p>Imaginemos cómo se ve el futuro cuando todo esto funcione:</p><h4>Crear una Wallet = Escanear Tu Cara</h4><p>Abres una app. “Crear wallet.” Escaneas tu cara. Listo. 10 segundos. No seed phrases. No estrés. Tu abuela puede hacer esto mientras cocina.</p><h4>Enviar Crypto = Tan Fácil Como Apple Pay</h4><p>Quieres pagar a alguien. Escaneas un QR. Confirmas con Face ID. Se fue. No copiar/pegar direcciones de 42 caracteres. No triple-checking. No ansiedad.</p><h4>Recovery = Tus Amigos Te Ayudan (On-Chain)</h4><p>Perdiste tu teléfono. Contactas a 3 de tus 5 guardianes. Ellos aprueban tu recovery on-chain. Obtienes acceso a una nueva passkey. Todo transparente. Todo auditable.</p><h4>Seguridad = El Chip de Tu Teléfono</h4><p>Tu clave privada nunca sale de hardware de seguridad militar. Ni siquiera tú puedes extraerla. Anti-phishing nativo a nivel de autenticación. Los keyloggers son inútiles.</p><h4>Open Source = Auditable Por Todos</h4><p>El código está abierto. Cualquiera puede verificar cómo funciona. Las vulnerabilidades se encuentran y parchean rápido. La confianza viene de transparencia, no de marcas.</p><h4>Self-Hostable = Sin Puntos de Falla Centralizados</h4><p>Puedes correr tu propio bundler. Tu propio paymaster. Tu propia infraestructura. O usar servicios de terceros. Tú eliges. La optionalidad es poder.</p><h4>Portable = Nunca Estás Atrapado</h4><p>No te gusta tu wallet? Migra a otra. Tus passkeys vienen contigo. Tus módulos funcionan igual. El vendor lock-in es cosa del pasado.</p><h4>Multi-Chain = Una Cuenta, Todas las Chains</h4><p>Tu smart account existe en Ethereum, Base, Arbitrum, Optimism, Polygon, todas. Una firma, replica en todas. Chain abstraction real.</p><p><strong>Esto no es utopía. Es simplemente ingeniería ejecutada correctamente.</strong></p><blockquote><em>Cada pieza individual ya existe. Solo necesitamos ensamblarlas y pulir las aristas.</em></blockquote><h3>Call to Action: ¿Qué Podemos Hacer?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*9ZZf34ZDLxyvwwV2" /></figure><p>Bien, has llegado hasta aquí. ¿Ahora qué?</p><h4>Si Eres Developer</h4><ul><li><strong>Construye con ERC-4337 y ERC-7579</strong>: Aprende los estándares. Construye smart accounts. Crea módulos. Contribuye al ecosistema. Las primitivas existen, pero necesitamos más builders usándolas.</li><li><strong>Prioriza vendor-neutrality</strong>: No te cases con un solo proveedor. Usa interfaces estándar. Haz tu código portable. El futuro es multi-provider.</li><li><strong>Educar y compartir conocimiento</strong>: Escribe tutoriales. Da charlas. Explica conceptos. La mayoría de devs no entienden Account Abstraction aún. Ayúdalos.</li><li><strong>Contribuye open source</strong>: ZKnox, Safe, otros proyectos necesitan contributors. Code reviews, documentación, ejemplos. Cada contribución cuenta.</li></ul><h4>Si Eres Founder/Builder</h4><ul><li>Integra smart accounts en tu producto: Si estás construyendo consumer crypto, smart accounts deberían ser tu default. La UX improvement es masiva.</li><li>Usa paymasters: Subsidia el gas para tus usuarios. Hazlo invisible. Crypto debería sentirse como Web2.</li><li>Implementa social recovery: Ofrece opciones de recovery desde día 1. No esperes a que alguien pierda fondos.</li></ul><h4>Para El Ecosistema</h4><ul><li><strong>Colaborar &gt; Competir</strong>: Estamos construyendo infraestructura pública. Los estándares compartidos benefician a todos.</li><li><strong>Insistir en open source</strong>: La closed-source UX de Base es tentadora, pero peligrosa. Necesitamos alternativas open-source competitivas.</li><li><strong>Balance UX ↔ Descentralización</strong>: No sacrifiquemos descentralización por conveniencia. Pero tampoco hagamos productos inutilizables por purismo. Busquemos el balance.</li></ul><p><strong>El futuro de crypto depende de que esto funcione.</strong></p><p>Si no resolvemos UX, crypto seguirá siendo un nicho de nerds. Si resolvemos UX pero perdemos descentralización, ¿qué estamos construyendo realmente?</p><p>Necesitamos ambos. Y por primera vez en la historia de crypto, <strong>realmente podemos tener ambos.</strong></p><h3>Para Profundizar: Referencias y Recursos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*1al43kdVkTgk54ho" /></figure><p>Si quieres ir más deep en cualquiera de estos temas:</p><h4>Estándares Fundamentales</h4><ul><li><a href="https://eips.ethereum.org/EIPS/eip-4337"><strong>EIP-4337 — Account Abstraction</strong></a>: El estándar que hace todo esto posible. Descripción completa de UserOperations, bundlers, paymasters, y más.</li><li><a href="https://erc7579.com/"><strong>ERC-7579</strong></a>: Minimal Modular Smart Accounts: Interfaces estándar para módulos, validators, executors, y hooks.</li><li><a href="https://github.com/ethereum/RIPs/blob/master/RIPS/rip-7212.md"><strong>RIP-7212</strong></a>: Precompile for secp256r1 Curve Support: La propuesta para hacer P-256 barato en el EVM.</li></ul><h4>Implementaciones</h4><ul><li><a href="https://github.com/ithacaxyz/porto"><strong>Porto by Ithaca</strong></a>: Documentación, SDK, y ejemplos. <a href="https://ithaca.xyz/">docs.ithaca.xyz</a></li><li><strong>Base Account by Coinbase</strong>: Smart wallet documentation: <a href="http://docs.base.org/smart-wallet">docs.base.org/smart-wallet</a> y <a href="http://www.smartwallet.dev/">www.smartwallet.dev</a>.</li><li><a href="https://github.com/get-smooth/crypto-lib"><strong>ZKnox crypto-lib by Smooth</strong></a>: Optimized primitives for P-256 and WebAuthn.</li><li><strong>Safe (Formerly Gnosis Safe)</strong>: El OG de smart accounts: <a href="http://docs.safe.global/">docs.safe.global</a> y <a href="http://github.com/safe-global">github.com/safe-global</a>.</li></ul><h4>Herramientas y Servicios</h4><ul><li><a href="https://docs.pimlico.io/"><strong>Pimlico</strong></a>: Bundler y paymaster como servicio.</li><li><a href="https://accountkit.alchemy.com/"><strong>Alchemy Account Kit</strong></a>: Toolkit para construir smart accounts.</li><li><a href="https://zerodev.app/"><strong>ZeroDev</strong></a><strong>:</strong> SDK para Account Abstraction.</li></ul><h4>Conceptos Criptográficos</h4><ul><li><strong>WebAuthn/FIDO2 Specification</strong>: El estándar detrás de passkeys. <a href="http://webauthn.guide/">webauthn.guide</a> y <a href="http://fidoalliance.org/fido2">fidoalliance.org/fido2</a></li><li><strong>Elliptic Curve Cryptography</strong>: Si quieres entender las matemáticas detrás de P-256 vs secp256k1.<a href="http://andrea.corbellini.name/ecc">andrea.corbellini.name/ecc</a></li></ul><h3>Conclusión: Estamos Más Cerca De Lo Que Piensas</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/0*wJDyOjzIiqf8y3rU" /></figure><p>Hemos cubierto mucho terreno. Desde seed phrases en papel hasta Face ID. Desde EOAs simples hasta smart accounts programables. Desde UX terrible hasta experiencias que tu abuela puede usar.</p><p><strong>Aquí está la verdad simple:</strong></p><ul><li>Las primitivas existen ✓</li><li>Los estándares están definidos ✓</li><li>Las implementaciones están llegando ✓</li></ul><p>Solo necesitamos que alguien lo ejecute bien.</p><p><strong>No es “si”, es “cuándo” y “quién”.</strong></p><blockquote><em>La carrera está en marcha. </em><strong><em>Porto </em></strong><em>tiene momentum técnico. </em><strong><em>Base </em></strong><em>tiene UX y recursos. </em><strong><em>ZKnox </em></strong><em>tiene transparencia y flexibilidad. Otros están construyendo en silencio.</em></blockquote><p>Quien logre combinar:</p><ul><li>UX perfecta (nivel Base)</li><li>Open source total (nivel ZKnox)</li><li>Vendor neutrality (portabilidad real)</li><li>Compatible con estándares (ERC-7579)</li></ul><p>…gana el futuro de crypto UX.</p><p><strong>Y ese futuro está a 12–18 meses, no 5 años.</strong></p><p>RIP-7212 llegará. La portabilidad de rpId se resolverá. Los wallets mainstream adoptarán Account Abstraction. Los costos de gas bajarán. La educación mejorará. Para 2027, explicarle a alguien qué es una seed phrase será como explicar qué es un fax. <em>“Espera, ¿solíamos hacer QUÉ?”</em></p><p><strong>La revolución de UX en crypto está sucediendo ahora</strong>. La pregunta no es si va a pasar. La pregunta es: ¿estarás construyéndola o solo mirando?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a538ca573c01" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Web3 y Smart Contracts en Python]]></title>
            <link>https://medium.com/@0xh/web3-y-smart-contracts-en-python-812fe0226bdc?source=rss-988d1eca1cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/812fe0226bdc</guid>
            <category><![CDATA[web3]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[solidity]]></category>
            <category><![CDATA[solidity-tutorial]]></category>
            <category><![CDATA[blockchain-development]]></category>
            <dc:creator><![CDATA[0xh]]></dc:creator>
            <pubDate>Thu, 17 Feb 2022 19:12:20 GMT</pubDate>
            <atom:updated>2022-02-17T19:12:20.615Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*uJI8pS4Wyna6HO1WOFaFQg.jpeg" /></figure><h3>Introducción</h3><p>Es frecuente utilizar <a href="https://web3js.readthedocs.io/en/v1.7.0/">web3.js</a> en aplicaciones web en conjunto con <a href="https://metamask.io/">Metamask</a>, que se encarga de la gestión de las claves privadas de la billetera, firma de las transacciones, interacción con distintas redes de blockchain, determinación del nonce de la transacción, etc. Sin Metamask, tenemos que tomar esas tareas nosotros. Se puede realizar tanto en JavaScript como en Python. Aquí lo mostraremos con Python.</p><p>A continuación, vamos a interactuar con un contrato inteligente, desplegado en Rinkeby (Ethereum) y Mumbai (Polygon) desde Python, haciendo uso de la librería <a href="https://web3py.readthedocs.io/en/stable/web3.eth.html">web3.py</a>.</p><h3>Requerimientos</h3><p>Lo primero que necesitamos es tener instalado Python y pip, que se puede descargar del sitio oficial:</p><p><a href="https://www.python.org/downloads/">Download Python</a></p><p>Luego, tenemos que instalar la dependencia a web3, que es tan sencillo como hacer:</p><pre>pip3 install web3</pre><p>Nota: si lo ejecutan en Linux, revisen de tener python3-dev y GCC en vuestra máquina</p><p>Vamos a interactuar con una red de prueba de Ethereum y Polygon, por lo que necesitaremos de un contrato inteligente desplegado en ellas. Podemos crear un simple contrato de storage:</p><pre>// SPDX-License-Identifier: MI<br>pragma solidity &gt;=0.6.0 &lt;0.9.0;<br><br>contract Storage{<br><br>  address payable internal owner;<br>  <br>  string private data;<br><br>  event DataSetted();<br><br>  constructor () public<br>  {<br>    owner = payable(msg.sender);<br>  }<br><br>  modifier onlyOwner()<br>  {<br>    require(msg.sender==owner);<br>    _;<br>  }<br><br>  function set(string memory newData) public {<br>    data = newData;<br>    emit DataSetted();<br>  }<br><br>  function get() public view returns (string memory _data) {<br>    return data;<br>  }<br><br>  function getVersion() public pure returns (string memory _version)    <br>  { <br>    return &quot;1.0&quot;;<br>  }<br><br>  function destroySmartContract() public onlyOwner {<br>    selfdestruct(owner);<br>  }<br>}</pre><p>Este contrato está desplegado ya en Rinkeby y Mumbai:</p><ul><li>Ethereum testnet (rinkeby): <a href="https://rinkeby.etherscan.io/address/0xb497D1572210AAF11D0C39b8307dC73EAB480cfC">0xb497D1572210AAF11D0C39b8307dC73EAB480cfC</a></li><li>Polygon testnet (mumbai): <a href="https://mumbai.polygonscan.com/address/0xf05eD004881fD8B0eeeAed908d53FDdD43525C12">0xf05eD004881fD8B0eeeAed908d53FDdD43525C12</a></li></ul><p>Por último, para realizar transacciones sobre el contrato, necesitaremos un nodo de Rinkeby y/o Mumbai. Para sortear el tener el nodo local, podemos utilizar un proveedor de nodos, como ser <a href="https://infura.io/">Infura</a> o <a href="https://www.alchemy.com/layer2/polygon">Alchemy</a>. En el primer caso, tendremos acceso a nodos gratis sobre Ethereum aunque para Polygon tiene un costo asociado. En el segundo caso (Alchemy) podremos acceder a las dos redes de manera gratuita.</p><p>Será necesario registrarse en alguno de estos dos proveedores y obtener un API KEY (project ID para el caso de Infura) para utilizar con el script de Python.</p><h3>Código en Python</h3><p>Debajo indicamos los pasos para realizar la conexión con el proveedor de web3, armar la transacción para interactuar con el contrato, realizar su firma y consumir los métodos get y set del contrato.</p><p>Para los interesados en el código completo, pueden verlo en <a href="https://github.com/dappsar/solidity-python">Github</a>.</p><p>Allí tendrán de manera detallada:</p><ul><li>Requerimientos.</li><li>Instalación y despliegue del contrato de manera local (con truffle) y en redes de prueba.</li><li>Testing del contrato.</li><li>Cómo obtener fondos para las billeteras de las redes de prueba a través del uso de “faucets”.</li><li>El uso de linters y formatters para Solidity, configurado en el package.json y ejecutable en Github actions.</li><li>Un workflow para Github actions.</li><li>Recepción y validación de parámetros en Python.</li></ul><h4>Conexión con web3 provider</h4><p>Para realizar la conexión con el proveedor (Infura o Alchemy):</p><pre># Configurar la key obtenida del provide:<br>w3 = Web3(Web3.HTTPProvider(providerUrl+providerKey))</pre><pre># Urls según provider y red:</pre><pre>alchemy_url_eth = &#39;https://eth-rinkeby.alchemyapi.io/v2/&#39;<br>infura_url_eth= &quot;https://rinkeby.infura.io/v3/&quot;<br>alchemy_url_polygon = &#39;https://polygon-mumbai.g.alchemy.com/v2/&#39;<br>infura_url_polygon = &#39;https://polygon-mumbai.infura.io/v3&#39;</pre><p>Tendremos que inyectar un middleware para web3, debido a POA:</p><pre>w3.middleware_onion.inject(geth_poa_middleware, layer=0)</pre><p>Qué es “geth_poa_middleware”?</p><p>Copio la documentación oficial (que se puede leer <a href="https://web3py.readthedocs.io/en/stable/middleware.html#geth-style-proof-of-authority">aquí</a>):</p><p><em>There is no strong community consensus on a single Proof-of-Authority (PoA) standard yet. Some nodes have successful experiments running, though. One is go-ethereum (geth), which uses a prototype PoA for it’s development mode and the Rinkeby test network.</em></p><p><em>Unfortunately, it does deviate from the yellow paper specification, which constrains the extraData field in each block to a maximum of 32-bytes. Geth’s PoA uses more than 32 bytes, so this middleware modifies the block data a bit before returning it.</em></p><p>Podemos verificar si estamos conectados correctamente al nodo de nuestro proveedor, con la siguiente línea de código:</p><pre>w3.isConnected()</pre><h4>ABI del contrato</h4><p>Para acceder a un contrato desde web3, la biblioteca necesita saber cómo deben codificar y decodificar los argumentos y los valores devueltos. Para ello, deberá especificar el ABI del contrato.</p><p>El compilador genera el ABI (en formato Json) y, éste cambia al desplegar un nuevo contrato, por lo que se pueden optar por diferentes estrategias de dónde tomarlo: desde un archivo, desde el entorno, directamente desde la red de blockchain en donde se despliega el contrato con un request, etc. Hay diferentes maneras, dependerá de las necesidades y buenas prácticas de CI/CD de DevOps. Aquí, para simplificar, lo dejamos en una variable en nuestro script de Python:</p><pre>abi = [{&quot;inputs&quot;:[],&quot;stateMutability&quot;:&quot;nonpayable&quot;,&quot;type&quot;:&quot;constructor&quot;},{&quot;anonymous&quot;:False,&quot;inputs&quot;:[],&quot;name&quot;:&quot;DataSetted&quot;,&quot;type&quot;:&quot;event&quot;},{&quot;inputs&quot;:[],&quot;name&quot;:&quot;destroySmartContract&quot;,&quot;outputs&quot;:[],&quot;stateMutability&quot;:&quot;nonpayable&quot;,&quot;type&quot;:&quot;function&quot;},{&quot;inputs&quot;:[],&quot;name&quot;:&quot;get&quot;,&quot;outputs&quot;:[{&quot;internalType&quot;:&quot;string&quot;,&quot;name&quot;:&quot;_data&quot;,&quot;type&quot;:&quot;string&quot;}],&quot;stateMutability&quot;:&quot;view&quot;,&quot;type&quot;:&quot;function&quot;},{&quot;inputs&quot;:[],&quot;name&quot;:&quot;getVersion&quot;,&quot;outputs&quot;:[{&quot;internalType&quot;:&quot;string&quot;,&quot;name&quot;:&quot;_version&quot;,&quot;type&quot;:&quot;string&quot;}],&quot;stateMutability&quot;:&quot;pure&quot;,&quot;type&quot;:&quot;function&quot;},{&quot;inputs&quot;:[{&quot;internalType&quot;:&quot;string&quot;,&quot;name&quot;:&quot;newData&quot;,&quot;type&quot;:&quot;string&quot;}],&quot;name&quot;:&quot;set&quot;,&quot;outputs&quot;:[],&quot;stateMutability&quot;:&quot;nonpayable&quot;,&quot;type&quot;:&quot;function&quot;}]</pre><p>Nota: tener en cuenta que el compilador puede dejar los valores booleanos en minúsculas, lo que no es reconocido por Python, por lo que será necesario normalizarlo. En éste caso, el dato normalizado es:</p><pre>&quot;anonymous&quot;:False</pre><h4>Conexión con el contrato</h4><p>Declaramos la variable que contendrá al contrato, haciendo uso del provider:</p><pre>sc = w3.eth.contract(address=dirección del contrato en eth / polygon, abi=abi)</pre><pre># Direcciones del contrato ya desplegado:<br># sc_adr_eth = &#39;0xb497D1572210AAF11D0C39b8307dC73EAB480cfC&#39;<br># sc_adr_polygon = &#39;0xf05eD004881fD8B0eeeAed908d53FDdD43525C12&#39;</pre><p>La librería, nos provee de un atributo llamado functions, que es una clase contenedora para las funciones del contrato. Cada función del contrato se muestra como un método de este objeto. Sin embargo, llamar a este método aún no invoca el contrato, sino que devuelve un objeto de tipo <em>ContractFunction</em>. Una vez que tenemos este objeto, podemos usarlo para hacer una llamada a una transacción:</p><p>Una simple llamada al método getVersion de nuestro contrato:</p><pre>print(&#39;Contract Version:&#39;, sc.functions.getVersion().call())</pre><h4>Armado de la transacción</h4><p>En el caso de transacciones de sólo lectura, podemos hacer un “call” como el punto anterior (para <em>getVersion</em>). Para transacciones de escritura, que requieren la firma con la billetera del usuario, tenemos que armar la transacción con algunos parámetros de la red, firmarla y, finalmente, ejecutarla.</p><p>Para el armado de la transacción, utilizamos “buildTransaction”, que arma la transacción sin ejecutarla.</p><pre>data = ‘sample-data</pre><pre>raw_transaction = sc.functions.set(data).buildTransaction({<br>  &#39;from&#39;: nuestra dirección de billetera, <br>  &#39;nonce&#39;: w3.eth.getTransactionCount(nuestra dirección de billetera)<br>})</pre><p>Donde:</p><ul><li><em>sc</em>: es la variable que declaramos antes, con el contrato.</li><li><em>set</em>: es el método que tiene nuestro contacto.</li><li><em>data</em>: el parámetro que pasamos al método set.</li></ul><p>Para el armado de la transacción, especificamos los datos requeridos: from y nonce. Otros datos opcionales:</p><ul><li><em>gasPrice</em>: se puede tomar del provider =&gt; w3.eth.gasPrice.</li><li><em>gas</em>: se puede especificar un valor del gas, tomándolo como parámetro a nuestro script.</li><li><em>chainId</em>: id de la cadena.</li><li><em>value</em>: si nuestro contrato requiere enviar <em>ethers </em>para alguna transacción, se especifica aquí.</li><li><em>to</em>: Es la dirección del contrato, aunque al utilizar el método <em>buildTransaction</em>, no hay que setearlo, ya que lo hace el propio método. En caso de setearlo, obtendremos un error en la ejecución de <em>buildTransaction</em>.</li></ul><h4>Firma de la transacción</h4><p>Utilizamos (sk) la clave privada de nuestra billetera para firmar la transacción:</p><pre>signed = w3.eth.account.signTransaction(raw_transaction, sk)</pre><h4>Envío de la transacción</h4><pre>receipt = w3.eth.sendRawTransaction(signed.rawTransaction)</pre><p>Aquí podemos obtener el hash de la transacción de manera bloqueante o no bloqueante. En el primer caso, esperando a que quede la transacción dentro de un bloque (que sea “minada”). En el segundo, la calculamos directamente nosotros.</p><pre># non-blockin<br>print (&#39;preview trx hash (trx could be in pending status)&#39;, w3.toHex(w3.keccak(signed.rawTransaction)))<br><br><br># blocking: Wait for the transaction to be mined, and get the transaction receipt<br>print(&#39;receipt with confirmed trx hash (after trx executed)&#39;, w3.eth.waitForTransactionReceipt(receipt))</pre><h4>Confirmación de los resultados</h4><p>Podemos hacer una llamada al método “get” de nuestro contrato, para validar que los datos hayan sido guardados:</p><pre>result = sc.functions.get().call()</pre><pre>print(&#39;\n\nresult saved in contract&#39;, result)</pre><p>Hemos visto cómo podemos conectarnos a un servidor RPC, enviar transacciones, obtener acceso a contratos inteligentes ya implementados e invocar sus funciones. La <a href="https://web3py.readthedocs.io/en/stable/quickstart.html">librería de web3.py</a> tiene extensa información y métodos. Su documentación es muy fácil de leer.</p><p><a href="https://web3py.readthedocs.io/en/stable/quickstart.html">Quickstart - Web3.py 5.28.0 documentation</a></p><p>Se puede acceder a ejemplo con los fuentes completos en <a href="http://%20https//github.com/dappsar/solidity-python">github</a>.</p><h3>Referencias</h3><ul><li><a href="https://infura.io/">Ethereum API | IPFS API &amp; Gateway | ETH Nodes as a Service</a></li><li><a href="https://www.alchemy.com/layer2/polygon">Polygon</a></li><li><a href="https://web3py.readthedocs.io/en/stable/web3.eth.html">web3.eth API - Web3.py 5.31.3 documentation</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=812fe0226bdc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Uso de Solidity en Hyperledger Fabric]]></title>
            <link>https://medium.com/@0xh/uso-de-solidity-en-hyperledger-fabric-bb9f1b552301?source=rss-988d1eca1cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb9f1b552301</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[hyperledger]]></category>
            <category><![CDATA[fabric]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[solidity]]></category>
            <dc:creator><![CDATA[0xh]]></dc:creator>
            <pubDate>Wed, 18 Dec 2019 13:42:15 GMT</pubDate>
            <atom:updated>2019-12-18T13:42:15.775Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ek-JM8X113T7AnQB90vFCg.jpeg" /></figure><p><strong>Hyperledger Fabric</strong> tiene como lenguaje de programación nativo <strong>chaincode </strong>[01], aunque en octubre del 2018 habilitó la posibilidad de desarrollar <strong>contratos inteligentes</strong> con el lenguaje de programación <strong>Solidity </strong>[02], lo que abre el abanico para desarrolladores que utilizan este lenguaje y quieren utilizar la infraestructura de Hyperledger.</p><p>Para permitir esto, tuvieron que implementar la <strong>API de Ethereum</strong> [03] (La API es una manera de hacer interactuar una aplicación cliente con la red <strong>Blockchain</strong>), aunque no lo han realizado en su totalidad [02]. Esa implementación se llama <strong>FAB3</strong>,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/878/1*3fnhnbktmBZMNyziGrN5YQ.png" /><figcaption>Fuente: <a href="https://github.com/hovig/web3-fabric-voting-dapp/raw/master/img/hyperether.png">https://github.com/hovig/web3-fabric-voting-dapp/raw/master/img/hyperether.png</a></figcaption></figure><p>El equipo de Hyperledger escribió un tutorial en github [04], el cual seguí, pudiendo desplegar un contrato de ejemplo escrito en Solidity sobre Fabric y Fab3. Anduvo bien. Inclusive luego tuve que realizar una prueba de estrés sobre diferentes plataformas de blockchain, en donde utilicé un simple contrato, desplegándolo sobre nodos de Ethereum y aproveché para estresar también la plataforma de fabric, desplegando ese mismo contrato (escrito en Solidity y sin tener que pasarlo a chaincode).</p><p>Les copio el paso a paso para probar un contrato de ejemplo sobre Fabric y FAB3, partiendo desde la instalación de Ubuntu sobre una instancia de GCP y herramientas necesarias. Omito algunas descripciones teóricas de cada punto, que se pueden encontrar en la documentación oficial [04].</p><h3>Paso 1: Crear una máquina en GCP</h3><p>Primero es necesario crear una instancia en GCP. Con los recursos mínimos recomendados por Google basta para la infraestructura. Dejo el link para los que desconozcan como crear una instancia en GCP:</p><p><a href="https://cloud.google.com/sql/docs/postgres/create-instance?hl=es">Crear instancias | Cloud SQL para PostgreSQL | Google Cloud</a></p><p>La instancia se creó con Ubuntu 18.04 LTS, 1 vCPU, 3,75 GB de memoria.</p><h3>Paso 2: Crear reglas de firewall</h3><p>Es requerido habilitar el puerto 5000 (TCP+UDP), de salida. Se puede realizar con una etiqueta que luego se asigna a la instancia, en las reglas de firewall del menú de GCP. Dejo el link a la documentación oficial de Google, para realizarlo:</p><p><a href="https://cloud.google.com/vpc/docs/using-firewalls?hl=es-419">Usar reglas de firewall | VPC | Google Cloud</a></p><h3>Paso 3: Configuración inicial de la instancia</h3><p>Creadas las reglas de firewall y asignadas a la instancia, ejecutamos los siguientes pasos para instalar las herramientas necesarias y configurar el ambiente antes de ir a la instalación del software de Hyperledger.</p><h4># Actualización del S.O</h4><pre>ssh-keygen</pre><p><a href="https://www.digitalocean.com/community/tutorials/como-configurar-las-llaves-ssh-en-ubuntu-18-04-es">Cómo configurar las llaves SSH en Ubuntu 18.04 | DigitalOcean</a></p><h4># Instalación de herramientas de base</h4><pre>sudo apt-get install -y apt-transport-https ca-certificates curl gnupg-agent software-properties-common python2.7</pre><h4># Creación de link simbólico para python</h4><pre>sudo ln -s /usr/bin/python2.7 /usr/bin/python</pre><h4># Instalación de NVM</h4><pre>curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.11/install.sh | bash<br><br>cd<br><br># Copiamos y pegamos lo que aparezca al final de la instalación para que quede vigente en la consola actual<br><br>export NVM_DIR=&quot;$HOME/.nvm&quot;<br><br>[ -s &quot;$NVM_DIR/nvm.sh&quot; ] &amp;&amp; \. &quot;$NVM_DIR/nvm.sh&quot;  # This loads nvm<br><br>[ -s &quot;$NVM_DIR/bash_completion&quot; ] &amp;&amp; \. &quot;$NVM_DIR/bash_completion&quot;  # This loads nvm bash_completion<br><br># Actualizamos la consola actual <br><br>source ~/.bashrc</pre><h4># Instalación de nodeJs con NVM</h4><pre>nvm install 10<br>nvm use 10.17.0<br><br>nvm alias default 10.17.0</pre><h4># Instalación del cliente de Ethereum</h4><pre>npm install -g ethereumjs-testrpc<br>sudo add-apt-repository -y ppa:ethereum/ethereum<br>sudo apt-get update -y<br><br>sudo apt-get install -y ethereum</pre><h4># Instalación de Docker</h4><pre>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -<br><br>sudo add-apt-repository &quot;deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable&quot;<br><br>sudo apt-get update -y<br><br>sudo apt-get install -y docker-ce docker-ce-cli containerd.io</pre><h4># Evitar el acceso con sudo de docker</h4><pre>sudo groupadd docker<br>sudo gpasswd -a $USER docker<br>sudo newgrp docker<br>sudo usermod -aG docker $USER<br><br># Si quedamos como root<br>exit<br><br># Acá es requerido salir y volver a ingresar la consola, para que tome los cambios. Hay algunas alternativas aqui (https://superuser.com/questions/272061/reload-a-linux-users-group-assignments-without-logging-out), para evitar recargar la consola.<br><br># Prueba de docker sin SUDO<br><br>docker run hello-world</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1002/1*cjlRJ1g2G__yLjOLlHx34Q.png" /><figcaption>Finalización de instalación de Docker (sin SUDO)</figcaption></figure><h4># Instalación de docker-compse</h4><pre>sudo curl -L &quot;https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)&quot; -o /usr/local/bin/docker-compose</pre><pre>sudo chmod +x /usr/local/bin/docker-compose</pre><pre>sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose</pre><pre>docker-compose --version</pre><h4># Instalación de GO</h4><pre>curl -O <a href="https://dl.google.com/go/go1.13.4.linux-amd64.tar.gz">https://dl.google.com/go/go1.13.4.linux-amd64.tar.gz</a> <br>tar -xvf go1.13.4.linux-amd64.tar.gz<br>sudo rm -rf /usr/local/go <br>sudo mv go /usr/local <br>mkdir $HOME/go </pre><pre># Editar el archivo profile y copiar los exports</pre><pre>sudo nano ~/.profile<br>export PATH=$PATH:/usr/local/go/bin<br>export GOROOT=/usr/local/go/ <br>export GOBIN=$GOROOT/bin <br>export GOPATH=$HOME/go <br>export PATH=$PATH:$GOBIN</pre><pre># Recargar el profile<br>source ~/.profile</pre><pre># Configuración de permisos<br>sudo chmod +x $GOROOT</pre><pre># Creación de carpetas para proyectos de GO</pre><pre>mkdir -p $GOPATH/src/github.com/hyperledger/</pre><h3>Paso 4: Clonación de proyectos de Fabric</h3><h4># Clonación del proyecto de ejemplo de Hyperledger Fabirc</h4><pre>cd $GOPATH/src/github.com/hyperledger/ <br>git clone <a href="https://github.com/hyperledger/fabric-samples.git">https://github.com/hyperledger/fabric-samples.git</a> <br>chmod 777 fabric-samples <br>cd fabric-samples </pre><pre>git checkout release-1.3</pre><h4># Clonación del SDK de Hyperledger Fabric</h4><pre>cd $GOPATH/src/github.com/hyperledger/ </pre><pre>git clone <a href="https://github.com/hyperledger/fabric-sdk-go.git">https://github.com/hyperledger/fabric-sdk-go.git</a></pre><h4># Clonación del proyecto fabric-chaincode-evm</h4><pre>cd $GOPATH/src/github.com/hyperledger/ <br>git clone <a href="https://github.com/hyperledger/fabric-chaincode-evm">https://github.com/hyperledger/fabric-chaincode-evm</a> <br>chmod 777 fabric-chaincode-evm <br>cd fabric-chaincode-evm <br>git checkout release-0.1</pre><h3>Paso 5: Clonación de proyecto de ejemplo</h3><h4># Clonación del proyecto de ejemplo de una aplicación de votación</h4><pre>cd $GOPATH/src/github.com/ <br>git clone <a href="https://github.com/hovig/web3-fabric-voting-dapp.git">https://github.com/hovig/web3-fabric-voting-dapp.git</a></pre><h3>Paso 6: Instalación de Fabric</h3><h4># Instalación de las imágenes docker de Hyperledger Fabric</h4><pre>cd $GOPATH/src/github.com/hyperledger/fabric-samples </pre><pre>./scripts/bootstrap.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F0KIcdUP1wsCmlH7tCPIPQ.png" /><figcaption>Contenedores instalados de Fabric</figcaption></figure><h4># Actualización del archivo de docker-compose con un nuevo volumen para incluir fabric-chaincode-evm.</h4><pre>cd $GOPATH/src/github.com/hyperledger/fabric-samples/first-network<br>rm -rf docker-compose-cli.yaml <br># Hay un punto al final de la instrucción, para copiar en el path actual<br>cp $GOPATH/src/github.com/web3-fabric-voting-dapp/scripts/docker-compose-cli.yaml .</pre><h3>Paso 7: Iniciar la red de Fabric</h3><h4># Iniciar una consola nueva con tmux (o screen)</h4><pre>tmux</pre><h4># Iniciar la red de Fabric</h4><pre>cd $GOPATH/src/github.com/hyperledger/fabric-samples/first-network </pre><pre>./byfn.sh -m down </pre><pre>./byfn.sh -m up</pre><pre># (tarda unos minutos en terminar)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yoYNd36kRYhf2_k6E4xW0g.png" /><figcaption>Inicio de la red de Fabric</figcaption></figure><h3>Paso 8: Instalar e instanciar EVM Chaincode</h3><h4># Entrar al conteneder de docker</h4><pre>docker exec -it cli bash</pre><pre># Si anduvo bien, debería mostrar algo como:</pre><pre>// root@containerid:/opt/gopath/src/github.com/hyperledger/fabric/peer#</pre><h4># Actualizar variables de entorno para apuntar a un determinado nodo</h4><pre>export CORE_PEER_MSPCONFIGPATH=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/users/Admin@org1.example.com/msp export CORE_PEER_ADDRESS=peer0.org1.example.com:7051 export CORE_PEER_LOCALMSPID=&quot;Org1MSP&quot; export CORE_PEER_TLS_ROOTCERT_FILE=/opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/peerOrganizations/org1.example.com/peers/peer0.org1.example.com/tls/ca.crt</pre><h4># Instalar EVM chaincode en todos los nodos</h4><pre>peer chaincode install -n evmcc -l golang -v 0 -p github.com/hyperledger/fabric-chaincode-evm/evmcc</pre><h4># Iniciar EVM chaincode</h4><pre># Fabric no soporta el uso de cuentas de usuarios, aunque se puede generar una dirección una cuenta desde la clave pública. Esa cuenta se usa por las transacciones del EVMCC. <br></pre><pre>peer chaincode instantiate -n evmcc -v 0 -C mychannel -c &#39;{&quot;Args&quot;:[]}&#39; -o orderer.example.com:7050 --tls --cafile /opt/gopath/src/github.com/hyperledger/fabric/peer/crypto/ordererOrganizations/example.com/orderers/orderer.example.com/msp/tlscacerts/tlsca.example.com-cert.pem</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tVDHQ3WxT07BbkHAce_5Sw.png" /></figure><h4># Salir del contenedor y volver a la terminal</h4><pre>exit</pre><h3>Paso 9: Armar el binario de FAB3</h3><pre># Dejar en background la terminal anterior e ingresar a una nueva terminal</pre><pre>tmux</pre><h4># Ejecutar los siguientes exports, que necesita el PROXY fab3</h4><pre># Path al SDK de Fabric</pre><pre>export FABPROXY_CONFIG=${GOPATH}/src/github.com/hyperledger/fabric-chaincode-evm/examples/first-network-sdk-config.yaml </pre><pre> # Usuario que utilizará el proxy </pre><pre>export FABPROXY_USER=User1 </pre><pre># Organización del usuario</pre><pre>export FABPROXY_ORG=Org1 </pre><pre># Canal a utilizarse en las transacciones</pre><pre>export FABPROXY_CHANNEL=mychannel </pre><pre># ID del EVM Chaincode desplegado en la red de Fabric</pre><pre>export FABPROXY_CCID=evmcc </pre><pre># Port en donde escuchará el proxy</pre><pre>export PORT=5000</pre><h4># Construir el binario de FAB3 con go</h4><pre>cd $GOPATH/src/github.com/hyperledger/fabric-chaincode-evm/</pre><pre>cd $HOME/go/src/github.com/hyperledger/fabric-chaincode-evm</pre><pre>go build -o fab3 ./fabproxy/cmd</pre><pre># Al finalizar, debería quedar un nuevo archivo, llamado “fab3”</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hCUVNt4AbmexD-GjMr4kmQ.png" /></figure><h4># Ejecutar el proxy FAB3 (iniciará FAB3 en <a href="http://localhost:5000/">http://localhost:5000</a>)</h4><pre>./fab3</pre><pre># Se verá como salido algo similar a esto:</pre><pre>{&quot;level&quot;:&quot;info&quot;,&quot;ts&quot;:1550530404.3546276,&quot;logger&quot;:&quot;fab3&quot;,&quot;caller&quot;:&quot;cmd/main.go:143&quot;,&quot;msg&quot;:&quot;Starting Fab3&quot;,&quot;port&quot;:5000}</pre><h3>Paso 10: Desplegar un contrato inteligente</h3><pre># Dejar ejecutándo en background la terminal anterior</pre><pre># Creación de carpeta de ejemplo<br>cd<br>mkdir test<br>cd test</pre><pre># Instalamos web 3 (funciona con la versión 0.20.2)<br>npm install web3@0.20.2</pre><pre># Ingresar a la consola de node<br>node</pre><pre># Asignar la librería web3<br>Web3 = require(&#39;web3&#39;) <br>web3 = new Web3(new Web3.providers.HttpProvider(&#39;http://localhost:5000&#39;))</pre><pre># Verificar la información de las cuentas<br>web3.eth.accounts</pre><pre># Asignar la cuenta por defecto a web3</pre><pre>web3.eth.defaultAccount = web3.eth.accounts[0]</pre><h4># En el compilador remix, obtener el ABI y bytecodes de nuestro contrato (podemos usar uno simple de la documentación de Ethereum)</h4><pre># Contrato</pre><pre>pragma solidity ^0.4.0;</pre><pre>contract SimpleStorage {</pre><pre>    uint storedData;</pre><pre>    function set(uint x) public {</pre><pre>        storedData = x;<br>    }</pre><pre>    function get() public view returns (uint) {</pre><pre>        return storedData;<br>    }<br>}</pre><pre># Link al código en Remix</pre><pre>https://remix.ethereum.org/#optimize=false&amp;version=soljson-v0.4.24+commit.e67f0147.js&amp;evmVersion=null&amp;appVersion=0.7.7</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/842/1*vxyBMQfzjFdbD3MVkNeQnQ.png" /><figcaption>Visualización del contrato en Remix, para copiar el ABI y Bytecode</figcaption></figure><pre># Asignar el ABI a una variable<br><br>abi=[<br>	{<br>		&quot;constant&quot;: false,<br>		&quot;inputs&quot;: [<br>			{<br>				&quot;name&quot;: &quot;x&quot;,<br>				&quot;type&quot;: &quot;uint256&quot;<br>			}<br>		],<br>		&quot;name&quot;: &quot;set&quot;,<br>		&quot;outputs&quot;: [],<br>		&quot;payable&quot;: false,<br>		&quot;stateMutability&quot;: &quot;nonpayable&quot;,<br>		&quot;type&quot;: &quot;function&quot;<br>	},<br>	{<br>		&quot;constant&quot;: true,<br>		&quot;inputs&quot;: [],<br>		&quot;name&quot;: &quot;get&quot;,<br>		&quot;outputs&quot;: [<br>			{<br>				&quot;name&quot;: &quot;&quot;,<br>				&quot;type&quot;: &quot;uint256&quot;<br>			}<br>		],<br>		&quot;payable&quot;: false,<br>		&quot;stateMutability&quot;: &quot;view&quot;,<br>		&quot;type&quot;: &quot;function&quot;<br>	}<br>]<br><br><br># Asignar el bytecode a una variable<br><br>bytecode=&quot;608060405234801561001057600080fd5b5060df8061001f6000396000f3006080604052600436106049576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff16806360fe47b114604e5780636d4ce63c146078575b600080fd5b348015605957600080fd5b5060766004803603810190808035906020019092919050505060a0565b005b348015608357600080fd5b50608a60aa565b6040518082815260200191505060405180910390f35b8060008190555050565b600080549050905600a165627a7a72305820dd34abbccc0496d0940c2a374287db226b58ba209d51582c559c9398f4cad3300029&quot;<br><br><br># Instanciar el contrato<br>SimpleStorage = web3.eth.contract(abi)<br>deployedContract = SimpleStorage.new([], {data: bytecode})<br>myContract = SimpleStorage.at(web3.eth.getTransactionReceipt(deployedContract.transactionHash).contractAddress)<br><br># Interactuar con el contrato<br>myContract.set(10)<br>myContract.get().toNumber()<br><br># Debería devolver el valor 10</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/870/1*r0H6HChD4ggzqaN9vp-Ddg.png" /><figcaption>Pruebas en la consola de Node</figcaption></figure><h3>Referencias</h3><p>[01] Hyperledger-fabric.readthedocs.io. (2019). <em>Chaincode Tutorials — hyperledger-fabricdocs master documentation</em>. [online] Available at: https://hyperledger-fabric.readthedocs.io/en/release-1.4/chaincode.html [Accessed 17 Dec. 2019].</p><p>[02] Hyperledger. (2019). <em>Hyperledger Fabric Now Supports Ethereum — Hyperledger</em>. [online] Available at: <a href="https://www.hyperledger.org/blog/2018/10/26/hyperledger-fabric-now-supports-ethereum">https://www.hyperledger.org/blog/2018/10/26/hyperledger-fabric-now-supports-ethereum</a> [Accessed 17 Dec. 2019].</p><p>[03] GitHub. (2019). <em>ethereum/wiki</em>. [online] Available at: <a href="https://github.com/ethereum/wiki/wiki/JSON-RPC">https://github.com/ethereum/wiki/wiki/JSON-RPC</a> [Accessed 17 Dec. 2019].</p><p>[04] Pallab, P. (2019). <em>hyperledger/fabric-chaincode-evm</em>. [online] GitHub. Available at: <a href="https://github.com/hyperledger/fabric-chaincode-evm/blob/master/examples/EVM_Smart_Contracts.md">https://github.com/hyperledger/fabric-chaincode-evm/blob/master/examples/EVM_Smart_Contracts.md</a> [Accessed 17 Dec. 2019].</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb9f1b552301" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Algorítmos de Consenso Raft y Paxos]]></title>
            <link>https://medium.com/@0xh/algor%C3%ADtmos-de-consenso-raft-y-paxos-b252e51e911a?source=rss-988d1eca1cd1------2</link>
            <guid isPermaLink="false">https://medium.com/p/b252e51e911a</guid>
            <category><![CDATA[paxos]]></category>
            <category><![CDATA[consensus]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[consenso]]></category>
            <category><![CDATA[raft]]></category>
            <dc:creator><![CDATA[0xh]]></dc:creator>
            <pubDate>Mon, 01 Jul 2019 11:39:07 GMT</pubDate>
            <atom:updated>2019-07-01T11:39:07.087Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*iNVweWVskcw9LaXslanMeQ.jpeg" /></figure><h3>RAFT</h3><p>Es un algoritmo de consenso, con el que se busca lograr consistencia en un grupo de nodos los cuales comparten información. Trabaja seleccionando un nodo líder sobre el que se realizan las solicitudes y coordinación del resto de los nodos para implementarlas. El clúster de nodos de raft, trabaja mientras que exista una mayoría (51%) de nodos en línea.</p><p>Los nodos participantes pueden estar en tres estados:</p><ul><li><strong>Líder</strong>: todos los cambios que se realicen en el cluster pasan por él primero.</li><li><strong>Seguidor</strong>: Nodo pasivo cuya responsabilidad es responder a las peticiones del nodo líder</li><li><strong>Candidato</strong>: nodo que no ha encontrado líder y solicita su elección.</li></ul><p>Cada nodo tiene un tiempo de espera <strong>aleatorio</strong> después del cual, si un líder no se comunica con él, pasa a estado candidato y pide ser elegido como líder.</p><p>El ejemplo por excelencia en donde se utiliza este algoritmo es en la escritura de un registro de log replicado.</p><p>Se puede ver una excelente visualización on-line del algoritmo, en el siguiente link: <a href="https://raft.github.io/">https://raft.github.io/</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/0*HBhplZsAO59jloqq" /></figure><p><strong>Ejemplo de situación de Raft con partición de Red</strong></p><p>En el siguiente ejemplo, se muestra gráficamente, una situación en la que Raft podría recuperarse de una partición de la red. Es decir, cuando una minoría de nodos queda durante un tiempo desconectado de la mayoría, y posteriormente se reconecta. Se plantea el caso de una red con 5 nodos, en donde ocurre una partición, quedando la red dividida en:</p><ul><li>El líder + 1 nodo</li><li>3 nodos</li></ul><p>Se grafica a partir del punto en que la red está particionada y hasta que vuelve a conectarse, en donde el resto de los nodos se re-sincroniza.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*r16O9y2n_3Bdodhqwr7nGg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/786/1*vyn5JUoPm7oQXMbd48ec9Q.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*0O6VisnDT9UU4D4YjIlhzQ.png" /></figure><h3>PAXOS</h3><p>Es un algoritmo de consenso que cuenta con cierto grado de tolerancia a fallos. Funciona con el modelo de paso de mensajes asincrónicos y con menos de n/2 fallos (pero no con fallos bizantinos), garantizando que se llegará a un acuerdo y a la finalización, si hay un tiempo suficientemente largo sin que ningún proceso reinicie el protocolo.</p><h4>Ejemplo de situación de PAXOS</h4><p>Supongamos que tenemos una red que está ejecutando el algoritmo <strong>Paxos </strong>para actualizar un valor y tenemos esta situación como se refleja en el diagrama siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/429/0*6DIinTHLN8osZYP7" /></figure><h4>¿Por qué se podría haber llegado a esa situación?</h4><p>Por lo que puedo interpretar del diagrama, es la primera fase del algoritmo, en donde se envían las solicitudes de preparación (prepare request). Hay dos proponentes (Proposer A y Proposer B) que envían una solicitud de preparación a tres aceptadores (Acceptor X, Acceptor Y y Acceptor Z).</p><p>La solicitud del proponente A, llega a los aceptadores X e Y antes de la solicitud del proponente B y la aceptan porque todavía no han prometido tener en cuenta otra solicitud con valor mayor que n. En el caso de la solicitud del proponente B, ésta llega primero al aceptador Z y es la que acepta, dado que el valor de n es mayor que la solicitud del proponente A.</p><h4>¿Cómo podríamos resolver la situación anterior?</h4><p>Respondo separando en tiempos en que suceden las propuestas y respuestas de aceptación.</p><p><strong>Tiempo T1:</strong></p><ul><li>Aceptador X: Recibe la propuesta del proponente A y la acepta, dado que no tiene una solicitud de propuesta anterior con un n mayor a 2. La manera en que “acepta” la propuesta de A, es responder al proponente A con una respuesta de preparación (prepare response) en donde se compromete a no aceptar otras propuestas con un número menor de rondas (n menor a 2).</li><li>Aceptador Y: Caso igual al del aceptador X.</li><li>Aceptador Z: Recibe la propuesta del proponente B y la acepta, por lo mismo explicado en el punto del Aceptador X.</li></ul><p>El gráfico del tiempo T1 sería el siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/408/1*BHlkRo9vWn9-kS4DIQ793Q.png" /></figure><p><strong>Tiempo T2:</strong></p><ul><li>Aceptador X: Recibe la solicitud del proponente B, en donde n es mayor al anterior (proponente A), así que ignora la solicitud anterior aceptando la nueva, por lo que envía una respuesta de preparación (prepare response) al proponente B con los valores previos recibidos (n=2 y v=8).</li><li>Aceptador Y: Mismo caso que el aceptador X.</li><li>Aceptador Z: Recibe la solicitud del proponente A, pero n es menor que el anterior, por lo tanto, ignora la solicitud.</li></ul><p>El gráfico del tiempo T2 sería el siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/409/1*5jNEQ-cmhftPB6g0smXmEA.png" /></figure><p><strong>Tiempo T3:</strong></p><p>Una vez que el proponente ha recibido las respuestas de preparación de la mayoría de los aceptadores, puede emitir una solicitud de aceptación (accept request). Eso es lo que hace el proponente A, pero en éste tiempo, los 3 aceptadores, ya tienen solicitudes con un n mayor al de A y se han comprometido con B para no aceptar solicitudes con un n menor a 4, por lo que rechazan ésta solicitud de aceptación. El proponente B, hace lo mismo, enviando las solicitudes de aceptación a cada aceptador. Los tres aceptadores, tienen un número de ronda (n=4), que corresponde a B, por lo que aceptan y envían una notificación (accepted) a cada nodo de aprendizaje (Learner).</p><p>El valor de V final que queda es 8, que difiere del que tenía originalmente B (5), porque es el valor más alto de los mensajes de respuesta de preparación (prepare response) que recibió B.</p><p>El gráfico del tiempo T3 sería el siguiente:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/458/1*bB9Rxx323DHNlJbJsYRCkg.png" /></figure><h3><strong>Comparación de Raft con Paxos</strong></h3><h4>Similitudes con Paxos:</h4><ul><li>Tanto Paxos como Raft suponen que eventualmente existirá un líder en el que todos los nodos estables confíen.</li><li>En ambos, todos los miembros del clúster son de confianza.</li><li>Ambos son tolerantes a fallos.</li><li>El número de nodos está predeterminado. Esto hace que en ambos algoritmos, sea difícil escalar. Además, con un número fijo de nodos, uno probablemente deba renunciar a la seguridad (al permitir que cualquier nodo se una) o al anonimato del nodo (para autenticarse).</li><li>Ambos tienen reglas para considerar las transacciones nuevas.</li><li>Tanto en Raft como en Paxos, el líder podría convertirse en un cuello de botella ya que todo el tráfico pasa por él.</li></ul><h4>Diferencias con Paxos:</h4><ul><li>Paxos tiene varios roles y reglas para las interacciones entre ellos. Raft no tiene nada de eso: solo son servidores, con uno de los servidores designado como líder.</li><li>En Paxos, solo se está administrando un solo valor de consenso; en Raft, se tiene una secuencia de entradas de registro.</li><li>Paxos se define en términos de mensajes. Raft está diseñado en términos de llamadas a procedimientos remotos (RPC).</li><li>En Raft, solo el servidor más actualizado puede convertirse en un líder, mientras que Paxos permite que cualquier servidor se convierta en un líder. Esta flexibilidad, sin embargo, viene con una complejidad adicional.</li><li>Paxos incluye un protocolo de dos fases para el consenso básico y un mecanismo separado para la elección del líder. A diferencia, Raft incorpora la elección del líder directamente en el algoritmo de consenso y lo usa como la primera de las dos fases de consenso.</li><li>En Raft, un servidor envía una “solicitud de líder” a otros servidores y espera una respuesta de la mayoría de ellos antes de considerarse un líder. Si no obtiene una respuesta de la mayoría de los servidores o un mensaje que indique que otro servidor se ha convertido en el líder, se agotará el tiempo de espera y se iniciará un nuevo proceso de elección. Los servidores solo pueden votar por una solicitud de líder por vez. Sin embargo, Paxos realmente no define cómo un servidor se convierte en un líder. Para simplificar, los investigadores explotan el rango a priori entre procesos tales como la identificación del servidor (por ejemplo, un número entero). Entonces, el servidor con el rango más alto o más bajo que no se sospecha se convierte en el nuevo líder.</li><li>Raft impone una restricción al proceso de elección del líder: sólo el servidor más actualizado puede convertirse en un líder. Básicamente, garantiza que un líder ha cometido entradas de términos anteriores y no necesita aprender acerca de entradas antiguas en el registro replicado de las que no tiene conocimiento. Entonces, después de convertirse en un líder, un servidor simplemente puede comenzar a “imponer” sus “deseos” en otros servidores. Paxos, sin embargo, permite que cualquier servidor se convierta en un líder. Por lo tanto, un servidor debe aprender sobre el pasado antes de comenzar a “imponer” sus “deseos” en otros servidores y, como siempre, la flexibilidad conlleva una complejidad adicional.</li><li>Ambos algoritmos deben evitar cuidadosamente sobrescribir una decisión tomada por un antiguo líder y, por lo tanto, violar la seguridad, pero lo hacen de enfoques diferentes:</li><li>En Raft, se determina cuál de los dos registros está más actualizado al comparar el índice y el término de las últimas entradas en los registros. Si los registros tienen las últimas entradas con términos diferentes, entonces el registro con el último término está más actualizado. Si los registros finalizan con el mismo término, el registro que sea más largo estará más actualizado. Entonces, el líder solo necesita asegurarse de que el registro duplicado en los servidores finalmente converja.</li><li>En Paxos, cualquier servidor puede convertirse en un líder, de modo que la tarea de evitar que una decisión no se sobreescriba se vuelve un poco más compleja ya que el nuevo líder tiene que descubrir qué han procesado otros servidores hasta ahora antes de comenzar a “imponer” su deseos “en otros.</li><li>Si hay un problema en la red en Paxos, se puede generar un fork. En el caso de Raft, deja de funcionar con menos de la mayoría de los nodos en línea.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b252e51e911a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>