Inicio
Bienvenido al Foro Comunitario de Sui
Gana tu parte de 1000 Sui
Gana puntos de reputación y obtén recompensas por ayudar a crecer a la comunidad de Sui.
Publicaciones de recompensas
+10
P&R expertosMay 29, 2025¿Por qué BCS requiere un orden de campo exacto para la deserialización cuando las estructuras Move tienen campos con nombre?
¿Por qué BCS requiere un orden exacto de los campos para la deserialización cuando las estructuras de Move tienen campos con nombre? He profundizado en la codificación y decodificación de BCS en Move, especialmente para la comunicación entre cadenas y el procesamiento de datos fuera de la cadena. Mientras estudiaba los ejemplos de la documentación de Sui Move, me encontré con algunos comportamientos que parecen contradictorios y estoy intentando entender las decisiones de diseño subyacentes. Según la especificación de BCS, «no hay estructuras en BCS (ya que no hay tipos); la estructura simplemente define el orden en el que se serializan los campos». Esto significa que, al deserializar, debemos usar peel_*las funciones exactamente en el mismo orden en que se definieron los campos de estructura. Mis preguntas específicas: Justificación del diseño: ¿Por qué BCS exige que los campos coincidan exactamente en el orden de los campos cuando las estructuras de movimiento tienen campos con nombre? ¿No sería más sólido serializar los nombres de los campos junto con los valores, de forma similar a JSON u otros formatos autodescriptivos? Interacción de tipos genéricos: Los documentos mencionan que «los tipos que contienen campos de tipo genérico se pueden analizar hasta el primer campo de tipo genérico». Considera esta estructura: struct ComplexObject has drop, copy { id: ID, owner: address, metadata: Metadata, generic_data: T, more_metadata: String, another_generic: U } ¿Cómo funciona exactamente la deserialización parcial aquí? ¿Puedo deserializar hasta more_metadata e ignorar ambos campos genéricos, o el primer campo genérico (generic_data) bloquea por completo la deserialización posterior? Coherencia entre idiomas: al utilizar la biblioteca JavaScript @mysten /bcs para serializar los datos que consumirán los contratos de Move, qué ocurre si: ¿Reordeno accidentalmente los campos del objeto de JavaScript? ¿La definición de la estructura Move cambia el orden de los campos en una actualización de contrato? ¿Tengo estructuras anidadas con sus propios parámetros genéricos? Implicaciones prácticas: En los sistemas de producción, ¿cómo gestionan los equipos la evolución del esquema BCS? ¿Versionan sus esquemas de BCS o esperan que el orden de los campos de las estructuras sea inmutable una vez implementados?
- Sui
- Move
51+10
P&R expertosMar 05, 2025«Errores de verificación de múltiples fuentes» en las publicaciones del módulo Sui Move: resolución automática de errores
Los desarrolladores que trabajan con Sui Move encuentran con frecuencia problemas relacionados con la aparición de varios errores de verificación del código fuente cuando intentan publicar o actualizar los módulos. Estos errores se producen debido a la falta de coincidencia entre las dependencias locales y las de la cadena, lo que provoca errores en las publicaciones y problemas de implementación. A continuación se muestra un ejemplo consolidado de los errores a los que se enfrentan los desarrolladores: Failed to publish the Move module(s), reason: [warning] Multiple source verification errors found: Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::vec_set Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::vec_map Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000001::MoveStdlib::bit_vector Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000001::MoveStdlib::ascii Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::hex Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::zklogin_verified_id Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::prover Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::coin Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::dynamic_field Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::transfer On-chain version of dependency Sui::zklogin_verified_id was not found. On-chain version of dependency Sui::zklogin_verified_issuer was not found. Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::tx_context Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::transfer_policy Local dependency did not match its on-chain version at 0000000000000000000000000000000000000000000000000000000000000002::Sui::kiosk Este problema a menudo surge debido a: Las versiones no coinciden entre el entorno de desarrollo local (por ejemplo, la CLI de Sui) y el estado de la cadena. Diferencias en las configuraciones de paquetes entre redes (por ejemplo, Mainnet frente a Testnet). Dependencias faltantes o desactualizadas en el entorno de la cadena. Preguntas clave ¿Cómo podemos automatizar la detección y resolución de estos desajustes de dependencia durante el proceso de publicación? ¿Qué herramientas o scripts se pueden desarrollar para garantizar que las dependencias locales siempre se alineen con sus homólogas de la cadena? ¿Hay alguna forma de agilizar este proceso integrando las comprobaciones de dependencias en las canalizaciones de CI/CD existentes o mejorando el SDK de Sui? Su tarea consiste en proponer una solución que aborde estos desafíos y garantice implementaciones más fluidas y confiables para los desarrolladores de Sui Move. Asegúrese de publicar su solución a continuación.
- Sui
- SDKs and Developer Tools
41Mejor Respuesta

- ... SUI0xduckmove+43
- ... SUIharry phan+36
- ... SUIHaGiang+31
- ... SUIPeera Admin+25
- ... SUIVens.sui+20
- ... SUIMarlKey+20
- ... SUIdudley_smith+16
Nuevos Artículos
- Codificación BCS en Sui: qué es y por qué es importanteArtículo0xduckmove263May 30, 2025
Si te estás basando en Sui o jugando con Move, es probable que hayas escuchado el término BCS por ahí. Es la abreviatura de la máquina formateadora de serialización canónica binaria creada originalmente para la cadena de bloques Diem, y ahora es la piedra angular de los ecosistemas basados en Move, como Sui, Aptos, Starcoin y 0L. Así que sí, es mejor que te sientas cómodo con ello si realmente quieres construir en este espacio. ¿Qué es BCS? La serialización canónica binaria (BCS) es un formato que se utiliza para serializar (codificar) y deserializar (decodificar) datos estructurados en bytes. Verás que se usa cuando: Codificar las transacciones antes de firmarlas. Emitir o analizar eventos desde la cadena de bloques. Interactuar con Move Smart Contracts fuera de la cadena a través de JavaScript. Sin embargo, BCS no incluye información de tipos en los bytes. Esto significa que debes conocer la estructura con antelación al decodificar, a diferencia de los formatos como JSON o Protocol Buffers, que se describen más por sí mismos. Características principales de BCS No hay ningún tipo de metadatos La salida serializada no contiene sugerencias sobre los tipos de campos. Debes saber a qué te enfrentas cuando decodificas. Serialización dependiente del pedido Las estructuras se codifican en el orden exacto de sus campos. Cambie el orden y la deserialización se interrumpirá. Esta es la razón por la que las funciones peel_* de Move deben coincidir con el diseño 1:1. Tipo genérico En una estructura como: struct BCSObject has drop, copy { id: ID, owner: address, meta: Metadata, generic: T } Solo puede deserializar de forma fiable hasta el metacampo. Los tipos genéricos estropean el análisis del BCS, así que póngalos siempre en último lugar si desea que sus datos se decodifiquen de forma segura. Uso de BCS en JavaScript Gracias a la biblioteca @mysten /bcs, puedes trabajar con BCS en JS como un profesional. npm i @mysten/bcs y un ejemplo básico: import { BCS, getSuiMoveConfig } from "@mysten/bcs"; const bcs = new BCS(getSuiMoveConfig()); const ser = bcs.ser(BCS.U16, 10); console.log(ser.toBytes()); // [0x0a, 0x00] const des = bcs.de(BCS.U16, ser.toBytes()); console.log(des); // 10 También puede serializar vectores y cadenas: bcs.ser("vector", [1, 2, 3, 4]); // 04 01 02 03 04 bcs.ser(BCS.STRING, "test string"); // 0b7465737420737472696e67 Registro de tipos personalizados Supongamos que tienes las siguientes estructuras de movimiento: struct Metadata has drop, copy { name: std::ascii::String } struct BCSObject has drop, copy { id: ID, owner: address, meta: Metadata } Puedes registrarlos así en JS: bcs.registerStructType("Metadata", { name: BCS.STRING, }); bcs.registerStructType("BCSObject", { id: BCS.ADDRESS, owner: BCS.ADDRESS, meta: "Metadata", }); Ejemplo de serialización y deserialización Serialización de JavaScript: const bytes = bcs .ser("BCSObject", { id: "0x0000000000000000000000000000000000000005", owner: "0x000000000000000000000000000000000000000a", meta: { name: "aaa" } }) .toString("hex"); console.log("Hex:", bytes); La salida puede ser: 0x0000000000000000000000000000000000000005000000000000000000000000000000000000000a03616161 Esto ahora puede transferirse a un contrato de Move o incluso probarse manualmente en la CLI de Sui. El BCS puede parecer de bajo nivel y con muchos bytes, pero una vez que comprendas cómo codifica los datos, comprenderás mejor cómo funcionan realmente los contratos inteligentes de Move y cómo conectar sistemas on-chain ↔ off-chain de forma segura. Y si estás depurando los bytes del BCS en Sui Explorer (como el que se muestra a continuación): Codificación BCS La serialización canónica binaria, o BCS, es un formato de serialización desarrollado en el contexto de la cadena de bloques Diem, y ahora se usa ampliamente en la mayoría de las cadenas de bloques basadas en Move (Sui, Starcoin, Aptos, 0L). El BCS no solo se usa en la máquina virtual Move, sino que también se usa en la codificación de transacciones y eventos, como la serialización de las transacciones antes de firmarlas o el análisis de datos de eventos. Saber cómo funciona BCS es crucial si quieres entender cómo funciona Move a un nivel más profundo y convertirte en un experto en Move. Vamos a sumergirnos. Especificaciones y propiedades del BCS Hay algunas propiedades de alto nivel de la codificación BCS que conviene tener en cuenta a medida que avancemos en el resto de la lección: El BCS es un formato de serialización de datos en el que los bytes de salida resultantes no contienen ningún tipo de información; por ello, la parte que reciba los bytes codificados necesitará saber cómo deserializar los datos En BCS no hay estructuras (ya que no hay tipos); la estructura simplemente define el orden en el que se serializan los campos Los tipos de contenedores se ignoran, por lo que OuterType y UnnestedType tendrán la misma representación de BCS: estructura: outerType { propietario: innerType } estructura InnerType { dirección: dirección } estructura UnnestedType { dirección: dirección } Los tipos que contienen los campos de tipo genérico se pueden analizar hasta el primer campo de tipo genérico. Por lo tanto, es una buena práctica poner los campos de tipo genérico en último lugar si se trata de un tipo personalizado que se va a ser/eliminar. struct bcSObject tiene drop, copy { id: ID, propietario: dirección, meta: metadatos, genérico: T } En este ejemplo, podemos deserializar todo hasta el metacampo. Los tipos primitivos, como las entradas sin signo, están codificados en formato Little Endian El vector se serializa con una longitud ULEB128 (con una longitud máxima de hasta u32) seguida del contenido del vector. La especificación BCS completa se encuentra en el repositorio BCS. Uso de la biblioteca de JavaScript @mysten /bcs Instalación La biblioteca que necesitará instalar para esta parte es la biblioteca @mysten /bcs. Puedes instalarla escribiendo en el directorio raíz de un proyecto de nodo: npm i @mysten /bcs Ejemplo básico Utilicemos primero la biblioteca de JavaScript para serializar y deserializar algunos tipos de datos simples: importar {BCS, getSuiMoveConfig} desde "@mysten /bcs «; //inicializa el serializador con las configuraciones predeterminadas de Sui Move const bcs = new BCS (getSuiMoveConfig ()); //Definir algunos tipos de datos de prueba entero constante = 10; matriz constante = [1, 2, 3, 4]; const string = «cadena de prueba» //usa bcs.ser () para serializar los datos const ser_integer = bcs.ser (BCS.U16, entero); const ser_array = bcs.ser («vector «, matriz); const ser_string = bcs.ser (BCS.STRING, cadena); //usa bcs.de () para deserializar datos const de_integer = bcs.de (BCS.U16, SER_Integer.toBytes ()); const de_array = bcs.de («vector «, ser_Array.toBytes ()); const de_string = bcs.de (BCS.STRING, ser_string.tobytes ()); Podemos inicializar la instancia del serializador con la configuración predeterminada integrada para Sui Move usando la sintaxis anterior, new BCS (getSuiMoveConfig ()). Hay enumeraciones integradas que se pueden usar para los tipos de Sui Move, como BCS.U16, BCS.STRING, etc. Para los tipos genéricos, se pueden definir usando la misma sintaxis que en Sui Move, como el vector del ejemplo anterior. Echemos un vistazo más de cerca a los campos serializados y deserializados: las entradas son hexadecimales mendianos 0a00 10 el primer elemento de un vector indica la longitud total, entonces son los elementos que están en el vector 0401020304 1,2,3,4 las cadenas son solo vectores de u8, con el primer elemento igual a la longitud de la cadena 0b7465737420737472696e67 cadena de prueba Escriba el registro Podemos registrar los tipos personalizados con los que trabajaremos usando la siguiente sintaxis: importar {BCS, getSuiMoveConfig} desde "@mysten /bcs «; const bcs = new BCS (getSuiMoveConfig ()); //Registrar el tipo de metadatos bcs.registerStructType («Metadatos», { nombre: BCS.STRING, }); //Lo mismo para el objeto principal que pretendemos leer bcs.registerStructType («bcsObject», { //BCS.ADDRESS se usa tanto para tipos de ID como para tipos de direcciones id: BCS.ADDRESS, propietario: BCS.ADDRESS, meta: «Metadatos», }); Uso de bcs en Sui Smart Contracts Continuemos con nuestro ejemplo de arriba con las estructuras. Definición de estructura Empezamos con las definiciones de estructura correspondientes en el contrato Sui Move. { //.. estructura Los metadatos han eliminado, copiado { nombre: std: :ascii: :String } struct bcSObject ha caído, copia { id: ID, propietario: dirección, meta: Metadatos } //.. } Deserialización Ahora, escribamos la función para deserializar un objeto en un contrato Sui. public fun object_from_bytes (bcs_bytes: vector): bcSObject { //Inicializa la instancia de bcs bytes let bcs = bcs: :new (bcs_bytes); //Usa peel_*funciones para eliminar los valores de los bytes serializados. //¡El orden tiene que ser el mismo que usamos en la serialización! let (id, owner, meta) = ( bcs: :peel_address (&mut bcs), bcs: :peel_address (&mut bcs), bcs: :peel_vec_u8 (&mut bcs) ); //Empaquete una estructura BCSObject con los resultados de la serialización BCSObject {id: object: :id_from_address (id), owner, meta: Metadata {name: std: :ascii: :string (meta)}} Los distintos métodos peel_* del módulo bcs de Sui Frame se utilizan para «separar» cada campo individual de los bytes serializados de BCS. Tenga en cuenta que el orden en que eliminamos los campos debe ser exactamente el mismo que el orden de los campos en la definición de la estructura. Cuestionario: ¿Por qué los resultados de las dos primeras llamadas a peel_address en el mismo objeto bcs no son los mismos? Observa también cómo convertimos los tipos de address a id y de vector a std: :ascii: :string con funciones auxiliares. Cuestionario: ¿Qué pasaría si BSCobject tuviera un tipo de UID en lugar de un tipo de ID? Ejemplo completo de Ser/De Encuentra los códigos de muestra completos de JavaScript y Sui Move en la carpeta example_projects. Primero, serializamos un objeto de prueba usando el programa JavaScript: //Construimos un objeto de prueba para serializarlo, ten en cuenta que podemos especificar el formato de la salida en hexadecimal let _bytes = bcs .ser («bcsObject», { id: «0x00000000000000000000000000000005", propietario: «0x0000000000000000000000000000000a», meta: {nombre: «aaa"} }) .toString («hexadecimal»); Queremos que la salida del escritor BCS esté en formato hexadecimal esta vez, que se puede especificar como se indica arriba. Añada el prefijo 0x a la cadena hexadecimal del resultado de la serialización y expórtela a una variable de entorno: export Object_hexstring=0x000000000000000000000000000000000005000000000000000000000000000000000000000000000000000A03616161 Ahora podemos ejecutar las pruebas unitarias de Move asociadas para comprobar que son correctas: Una prueba de movimiento adecuada Deberías ver esto en la consola: CONSTRUYENDO bcs_move Ejecutando pruebas unitarias de Move [PASS] 0x0: :bcs_object: :test_deserialization Resultado de la prueba: OK. Total de pruebas: 1; superadas: 1; fallidas: 0 O podemos publicar el módulo (y exportar el PACKAGE_ID) y llamar al método emit_object utilizando la cadena hexagonal serializada de BCS anterior: sui client call --function emit_object --module bcs_object --package $PACKAGE_ID --args $OBJECT_HEXSTRING A continuación, podemos comprobar la pestaña Eventos de la transacción en el explorador Sui para comprobar que hemos emitido el BCSObject deserializado correctamente:
1 - Hackeo del protocolo Cetus: el mayor exploit de DeFi en SuiArtículoVens.sui134May 29, 2025
En mayo de 2025, el mundo de las DeFi se vio sacudido por una de las brechas de seguridad más importantes de la historia reciente. Cetus Protocol, uno de los principales protocolos de intercambio descentralizado (DEX) y liquidez de la cadena de bloques Sui, fue víctima de un sofisticado hackeo que provocó pérdidas que superaron los 200 millones de dólares. Este incidente no solo conmocionó a la comunidad de DeFi, sino que también generó serias preocupaciones sobre la seguridad de los contratos inteligentes y la solidez de los protocolos basados en cadenas de bloques emergentes como Sui. Cetus Protocol se había establecido como el principal DEX de la red Sui, ofreciendo a los usuarios una plataforma para intercambiar tokens y proporcionar liquidez. Como componente clave de la infraestructura dentro del ecosistema Sui, Cetus desempeñó un papel fundamental a la hora de facilitar el comercio descentralizado y contribuir a la liquidez general de la red. Su prominencia lo convirtió en un objetivo atractivo para los actores malintencionados que buscan explotar las vulnerabilidades en su base de código. Se desarrolla el hackeo de Cetus La violación se produjo el 22 de mayo de 2025, cuando los atacantes identificaron y explotaron una falla crítica en la lógica de los contratos inteligentes de Cetus. Concretamente, la vulnerabilidad se debía a un sutil error de desbordamiento aritmético que permitía al pirata informático manipular los mecanismos de contabilidad internos del protocolo. Al utilizar fichas falsas y manipular las curvas de precios de los fondos de liquidez, el atacante pudo drenar enormes cantidades de fondos sin activar sistemas de detección inmediata. Aproximadamente a las 3:52 a.m. PT (11:52 UTC), los monitores de la cadena de bloques comenzaron a detectar transacciones irregulares en varios fondos de liquidez de Cetus. En cuestión de horas, quedó claro el alcance de los daños: se habían desviado activos del protocolo por valor de más de 260 millones de dólares. Los fondos robados se intercambiaron rápidamente y se transfirieron a otras cadenas de bloques, lo que complicó los esfuerzos de recuperación. Impacto en el mercado y en el ecosistema Sui Las secuelas del hackeo fueron rápidas y graves. Las operaciones en Cetus se interrumpieron de inmediato, ya que los desarrolladores se apresuraron a evaluar la situación y mitigar las pérdidas adicionales. Mientras tanto, el valor de los tokens nativos asociados a la plataforma se desplomó, y algunos experimentaron caídas de hasta el 80% en cuestión de horas. Los inversores y los usuarios se enfrentaron a pérdidas masivas y la confianza en el ecosistema Sui se vio afectada. Un hecho particularmente alarmante se produjo cuando la red Sui intentó adoptar una controvertida contramedida: votar a favor de congelar la cartera del atacante que contenía 160 millones de dólares de los fondos robados. Si bien esta medida demostró un enfoque proactivo para la recuperación de activos, también generó debates sobre los principios de descentralización y sobre si tales acciones socavaban la confianza en la inmutabilidad de las transacciones basadas en la cadena de bloques. En un momento dado, el USD SUI perdió un 5% y el USD CETUS perdió un +- 40%, lo que supuso un salto increíble y aterrador a la vez. Detalles técnicos del exploit del protocolo Cetus Según el análisis proporcionado por la empresa de ciberseguridad Halborn, la causa principal del exploit radica en la forma en que Cetus validaba ciertas operaciones aritméticas durante el intercambio de tokens. Un descuido en la gestión de grandes cantidades provocó una situación de desbordamiento, que el atacante manipuló hábilmente para crear desequilibrios artificiales en los fondos de liquidez. Luego, estos desequilibrios se aprovecharon para extraer activos reales del sistema sin compensar adecuadamente a los proveedores de liquidez. Este tipo de vulnerabilidad es particularmente insidiosa porque no siempre se manifiesta en condiciones operativas normales; por el contrario, para activarla se requieren casos extremos específicos relacionados con valores muy elevados o secuencias de transacciones inusuales. Estos errores son notoriamente difíciles de detectar durante las auditorías y las fases de prueba estándar, lo que los convierte en los principales candidatos para que los exploten adversarios con muchos recursos. Esfuerzos de respuesta y recuperación de la Fundación Cetus y Sui (también conocida como Mysten Labs) Durante el ataque, según se informa, se congelaron alrededor de 160 millones de dólares que se devolverán a las piscinas de Cetus. Es por eso que toda la fundación Sui inició una votación para descongelar estos tokens. Tras el ataque, el equipo de Cetus emitió declaraciones públicas en las que reconocía la violación y describía los pasos a seguir para solucionarlo. Trabajaron en estrecha colaboración con empresas de análisis de cadenas de bloques como Elliptic y Chainalysis para rastrear el movimiento de los fondos robados e identificar posibles vías de recuperación. Además, surgieron debates sobre la implementación de actualizaciones de emergencia para corregir las vulnerabilidades existentes y mejorar la resiliencia futura contra ataques similares. Los miembros de la comunidad expresaron reacciones encontradas ante estos desarrollos. Si bien muchos elogiaron la transparencia demostrada por el liderazgo de Cetus tras el hackeo, otros criticaron la falta de preparación para estos escenarios y cuestionaron si se habían implementado suficientes salvaguardias antes del lanzamiento.
1 - Mi primer artículo ZKat: Autenticación que preserva la privacidad para cadenas de bloques públicasArtículoHaGiang139May 25, 2025
Porque la transparencia no debería significar revelar tus secretos. En la mayoría de las cadenas de bloques públicas actuales, cada transacción e identidad de usuario es visible públicamente. Si bien la transparencia es una de las principales fortalezas de la cadena de bloques, se produce a costa de la privacidad, especialmente en lo que respecta a la autenticación. ZKat, abreviatura de autenticadores de conocimiento cero, es una primitiva criptográfica novedosa que lleva la autenticación que preserva la privacidad al mundo de la cadena de bloques. Con ZKat, los usuarios pueden demostrar que están autorizados a realizar una transacción sin revelar las reglas o políticas en las que se basa esa autorización. ##El problema de los enfoques tradicionales Los intentos anteriores de mantener la privacidad en la autenticación, como el uso defirmas umbrales, solo podían ocultar información limitada. Por ejemplo, podían ocultar qué usuarios habían firmado una transacción, pero no mucho más. También tenían problemas conpolíticas de autenticación más complejas(como combinaciones de roles, identidades o reglas). ZKat cambia el juego de la siguiente manera: Apoyando políticasarbitrariamente complejas Permitir estructuras flexibles, como lascombinaciones de firmas de múltiples esquemas Mantener lapolítica completa ocultaal público** ##Cómo funciona ZKat Para crear ZKat, los autores diseñaron uncompiladorque transforma el sistema zk-SNARKGroth16, ampliamente utilizado, en un nuevo tipo de pruebaNon-Interactive Zero-Knowledge (NIZK), que admiteclaves de verificación equívocas. ¿Qué significa eso? Significa que el verificadorno puede decirqué política se está utilizando, pero la prueba lo convence de que es válida. Se trata de una propiedad criptográfica completamente nueva que se presentó en el documento y es la base de cómo ZKat garantiza laprivacidad de las políticas. Pero los autores no se detuvieron en ZKat. Fueron un paso más allá conzKat, una versión que admiteactualizaciones ignoradas. En resumen: El emisor de una política puede actualizar la política de autenticación sin revelar nada nuevo Esto es muy poderoso en los sistemas de cadenas de bloques del mundo real, donde las políticas pueden necesitar evolucionar; por ejemplo, las DAO actualizan las reglas de votación o las instituciones rotan las teclas. También exploran el uso depruebas zk-recursivaspara hacer que zkatsea escalable y adecuado para la integración de la cadena de bloques. Los investigadores implementaron zKat en un prototipo de autenticación basada en umbrales. Su evaluación muestra: El rendimiento está a la par con el de los umbrales tradicionales ZKat admitepolíticas mucho más complejas ¡Todo eso, congastos generales mínimos
1 - ¿Qué es IKA? «No solo el bombo publicitario 👀»Artículo0xduckmove263May 19, 2025
(p/s: No es una de esas «actualizaciones de la web 3» que dan 3 líneas de tonterías y lo llaman alpha 😮💨) Lee el artículo completo: https://x.com/InternSui81687/status/1897309368644985108 ¿Alguna vez has movido activos entre cadenas y te has sentido como si fueras Indiana Jones esquivando trampas? ¿Sí?. Esto se debe a que la interoperabilidad en este momento = puentes riesgosos y puntos centrales de falla. Ika dice: «No, ya terminamos con eso». Están creando un sistema que ofrece un enfoque automático rápido y fiable, y que no le da las llaves a nadie. Basado en Sui, utiliza el cifrado Threshold y 2PC-MPC En el vídeo aquí, David Lash (cofundador de Ika) dice sin rodeos lo que todo el mundo piensa: la interoperabilidad es un enfoque automático roto. Y en lugar de escribir otro blog sobre «necesitamos una solución», como hacen la mayoría de los equipos, dedicaron dos años a buscar a expertos en seguridad, expertos en inteligencia artificial y académicos para crear una solución. ¿Qué se les ocurrió? Un sistema que utiliza MPC a dos jugadores y cifrado por umbral: palabras sofisticadas que básicamente significan: tus claves siguen siendo tuyas, tus activos no se vuelven a empaquetar como si fuera un regalo de Navidad de 2017 y todo va muy rápido. Por ejemplo, Ika no solo protege tus cosas. Realiza transacciones con una latencia inferior a un segundo y aún así permanece descentralizado. Mientras tanto, los puentes están aquí tardando 8 minutos y tu alma en confirmar un intercambio. Construyeron esto en Sui. Y si has dormido con Sui hasta ahora, esa siesta ha terminado. El modelo centrado en objetos de Sui, su vertiginosa finalidad y el Consenso de Mysticeti (sí, eso existe, no, no es inventado) son perfectos para lo que Ika está intentando hacer. David llegó a decir que la experiencia de Sui como desarrollador la convertía en una opción obvia, algo poco elogiado en el mundo de las criptomonedas, donde cada herramienta de desarrollo parece un pergamino antiguo. Pero lo que realmente me impresionó fue su opinión sobre la experiencia de usuario. ¿La mejor criptomoneda? Del tipo que es aburrido. No de mala manera, sino del tipo «simplemente funciona». Ika busca un futuro en el que ni siquiera sepas que estás haciendo cosas de cadenas cruzadas. Sin ventanas emergentes, sin puentes, sin fichas falsas. Solo tienes que abrir tu monedero, prestar tus BTC de forma nativa, hacer un intercambio entre cadenas y seguir adelante. Eso es lo que hemos estado pidiendo y, de alguna manera, nos olvidamos de exigirlo. Y no pienses que esto es solo para Degen Bros. Ika permite a los DAO, a los equipos independientes y a las empresas implementar sus propias soluciones de custodia (pensemos en el «paquete de inicio de Fireblocks»), pero con esteroides y de hecho accesibles. Ya no necesitas una configuración de 500 000 dólares para crear una infraestructura segura. Solo Sui, Ika y un poco de coraje. Ah, y no nos quedemos con Bitcoin. BTC ha estado al margen durante años, como ese tío que se niega a unirse al juego. Pero Ika lo está haciendo jugable. DeFi sin envoltorio ni movimiento: basta con guardarlo como garantía nativa y listo. A las instituciones les va a encantar porque les permite cumplir con las normas y ser eficientes. Sin fraude fiscal, sin trampas de custodia. Solo capital que fluye de forma limpia. Entonces, si alguien te pregunta: «¿Qué sigue para las criptomonedas?» no les envíes un hilo de tuits que diga «La interoperabilidad es el futuro»
1 - ¿Qué es IKA y por qué tanta publicidad?ArtículoRogueRig134May 13, 2025
@ikadotxyz, la red MPC paralela ultrarrápida de la cadena de bloques Sui, está generando mucha expectación por su potencial para revolucionar la seguridad y la interoperabilidad de la Web3. Las publicaciones recientes en X destacan el sentimiento alcista: según se informa, IKA cotiza entre 4,90 y 10 dólares en plataformas previas a la comercialización, como Whales, a pesar de tener una oferta de mil millones de fichas. Esto apunta a una posible capitalización bursátil de miles de millones si se mantiene el impulso, impulsado por una inversión estratégica de 21 millones de dólares por parte de la Fundación Sui y una campaña artística sin precedentes de 1,4 millones de dólares en SUI NFT. La latencia de menos de un segundo de Ika y su capacidad para escalar cientos de nodos firmantes la convierten en un punto de inflexión para las aplicaciones DeFi, la custodia descentralizada y las aplicaciones entre cadenas. Se espera que el próximo lanzamiento del token IKA en Sui desbloquee una nueva utilidad, lo que impulsará una mayor adopción. Los usuarios de X están entusiasmados con el papel de IKA en el programa de fidelización @GiveRep, y algunos lo consideran una de las mayores oportunidades de lanzar desde el aire a Sui. Dicho esto, los precios previos a la comercialización pueden ser volátiles y especulativos, por lo que no se garantiza que el rango entre 4,90 y 10 dólares se mantenga después del lanzamiento. Investiga siempre los fundamentos del proyecto (consulta los canales oficiales de Ika para obtener información más detallada) y sopesa los riesgos antes de lanzarte. El ecosistema de Sui se está calentando, pero no hay nada seguro en el mundo de las criptomonedas
1 - Configuración del nodo SUI: una guía detalladaArtículoRogue129May 13, 2025
Para configurar un nodo Sui, necesitarás instalar los binarios Sui, clonar el repositorio Sui y configurar el nodo. Puedes compilar desde el código fuente o usar Docker. Una vez que el nodo esté en ejecución, puedes supervisar su estado y sincronizar el progreso. Pasos detallados: Instale Sui Binaries: Siga las instrucciones de la documentación de Sui para instalar los binarios de Sui. Si utilizas Docker, sigue las instrucciones del archivo Readme de Docker del nodo completo de Sui. Si compilas desde el código fuente, tendrás que clonar el repositorio de Sui y compilarlo. Configure el nodo: Nodo completo: puedes configurar un nodo completo de Sui usando Docker o compilándolo desde el código fuente, de acuerdo con la documentación de Sui. Nodo validador: sigue las instrucciones de la configuración del nodo validador Sui para configurar un nodo validador. Esto incluye la instalación y configuración de la Sui, la administración de claves y la configuración del almacenamiento. Configuración completa del nodo: Cierre cualquier nodo completo en ejecución. Elimine la base de datos y el archivo genesis.blob. Obtenga el código fuente de la versión más reciente. Restablece tu sucursal. Descarga la última versión de Genesis Blob. Actualiza tu archivo de configuración fullnode.yaml, si es necesario. Reinicia tu nodo Sui Full. Ejecute el nodo: Inicie el nodo Sui con el comando apropiado para su método de configuración (por ejemplo, los comandos sui-node o Docker). Supervise el nodo: Supervisa el estado de tu nodo, sincroniza el progreso y los registros para asegurarte de que funciona correctamente. Usa herramientas como el registro, el seguimiento y las métricas para supervisar el nodo. El puerto de métricas predeterminado es el 9184, pero puedes cambiarlo en el archivo fullnode.yaml. Pasos adicionales: Registro del comité: si tienes un nodo validador, tendrás que registrarte en el comité. Liquid Staking: si gestionas un nodo, también puedes participar en el Liquid Staking. Sincroniza tu bifurcación: si contribuyes al proyecto Sui, tendrás que sincronizar tu bifurcación con el repositorio principal. Si sigues estos pasos, puedes configurar y ejecutar correctamente un nodo Sui.
1 - «Decodificando la trilogía Sui: pavimentando el futuro de la infraestructura Web3ArtículoHaGiang139May 12, 2025
Al explorar el mundo de la Web3, más allá de la búsqueda habitual de velocidades de transacción más rápidas y comisiones más bajas, surgen cada vez más desafíos estructurales más profundos. ¿Cómo se pueden almacenar cantidades masivas de datos de forma económica? ¿Cómo se puede proteger de forma segura la información confidencial en un entorno descentralizado? ¿Se pueden ejecutar de manera eficiente los cálculos complejos fuera de la cadena y, al mismo tiempo, tener sus resultados verificados y confiables dentro de la cadena? Muchos proyectos intentan abordar estos problemas mediante la combinación de varios servicios de terceros. Sin embargo, este camino suele conllevar una complejidad de integración, posibles problemas de confianza y una experiencia de usuario fragmentada. Ante estos desafíos a nivel de infraestructura, la cadena de bloques Sui y su equipo principal de desarrollo, Mysten Labs, han propuesto una solución más integrada. En lugar de basarse en un mosaico de herramientas externas, han diseñado una cadena de bloques con una arquitectura única, que incluye su modelo centrado en objetos y el lenguaje de programación Move, al tiempo que crean tres componentes de infraestructura nativa estrechamente conectados: Walrus, Seal y Nautilus. El objetivo de este artículo es analizar los conceptos de diseño en los que se basan estos tres componentes, explorar cómo funcionan, cómo se relacionan entre sí y qué cambios reales podrían aportar a las aplicaciones Web3. La arquitectura única de Sui Para entender cómo funcionan estas tres herramientas en Sui, primero debemos analizar algunas características clave de la propia plataforma Sui. Una de las principales innovaciones de Sui es su modelo orientado a objetos, un cambio fundamental con respecto a la arquitectura tradicional basada en cuentas. Sui trata los tokens, las NFT e incluso las estructuras de datos complejas como «objetos» independientes. Imagine administrar cada activo como una caja separada en lugar de registrar todo en un solo registro. Este diseño permite procesar en paralelo acciones no relacionadas (como la gestión de dos NFT no relacionadas), lo que mejora el rendimiento. Esta granularidad de los objetos crea una sinergia natural con Walrus y Seal: Walrus trata los datos almacenados como objetos, mientras que Seal puede adjuntar reglas de permisos directamente a objetos individuales. Además, Sui usa el lenguaje de programación Move, diseñado específicamente para administrar activos digitales. Move hace hincapié en la seguridad y tiene como objetivo reducir muchas vulnerabilidades comunes de los contratos inteligentes a nivel lingüístico. Esta sólida base hace que sea ideal para crear componentes de infraestructura sólidos. Al alinear el diseño de la cadena y el desarrollo de la infraestructura bajo un mismo techo (Mysten Labs), Sui tiene como objetivo ofrecer una experiencia de desarrollador más fluida y sinérgica. Walrus: almacenamiento descentralizado programable y económico Almacenar archivos grandes (imágenes, vídeos, modelos de IA, denominados colectivamente blobs) directamente en cadena es notoriamente caro. Cada una de las soluciones de almacenamiento descentralizado existentes tiene sus ventajas y desventajas, pero Walrus busca un nuevo equilibrio entre la rentabilidad y la interactividad de los contratos inteligentes, abordando directamente las barreras de costos que representan los datos en cadena a gran escala. La base de Walrus es la codificación de borrado, una ingeniosa técnica que «fragmenta» un archivo y añade «pistas de recuperación» para que el archivo pueda reconstruirse incluso si se pierden partes. Walrus llama a estos fragmentos adicionales «Red Stuff». Piénsalo de esta manera: si tienes dos números, digamos 3 y 5, y guardas ambos junto con su suma (8), perder el 3 no es catastrófico; puedes recuperarlo usando 8 - 5 = 3. Los fragmentos de recuperación adicionales desempeñan una función similar, ya que están matemáticamente relacionados con los originales. Tras fragmentarlos y codificarlos, Walrus distribuye estos fragmentos en muchos nodos. Incluso si faltan algunos fragmentos, el sistema puede reconstruir el archivo original siempre que se recupere un número límite de fragmentos, lo que ahorra mucho espacio en comparación con la replicación completa del archivo. Este enfoque reduce drásticamente los costos de almacenamiento y podría acercar los precios del almacenamiento descentralizado a los de los proveedores de nube centralizados. Aún más interesante, Walrus aprovecha el modelo de objetos de Sui: cada archivo almacenado se convierte en un objeto programable en cadena. Los desarrolladores pueden usar Move para redactar contratos inteligentes que administren estos objetos de almacenamiento: establecer reglas de acceso, actualizar automáticamente los metadatos, etc. El almacenamiento ya no es solo pasivo, sino que se convierte en un recurso programable de forma nativa. También hay una capa de utilidad basada en los tokens: para interactuar con los datos de Walrus en Sui, se necesitan tokens de SUI para registrar los metadatos (como los nombres de los archivos, los tamaños y las ubicaciones de almacenamiento) y, potencialmente, bloquear los tokens para pagar las tarifas de almacenamiento. Si la adopción de Walrus aumenta, la demanda de esta tecnología podría aumentar, lo que reduciría la oferta. Seal: La bóveda descentralizada y el guardián de acceso Muchas aplicaciones Web3 manejan datos confidenciales: identificaciones de usuario, detalles financieros, contenido de pago. En un contexto descentralizado, ¿cómo se almacenan los secretos de forma segura y se controla el acceso a ellos? Seal es una solución descentralizada de gestión de secretos (DSM) diseñada para responder a esa pregunta. Una de sus tecnologías principales es Threshold Encryption. Imagine una bóveda que requiere dos llaves para abrirse, cada una de las cuales está en manos de una persona diferente. Del mismo modo, el cifrado de umbral divide las claves de descifrado en varias partes y las distribuye a servidores de claves independientes. Solo cuando un número predefinido de ellas colaboran (el umbral) se pueden descifrar los datos; ningún servidor puede hacerlo por sí solo, lo que genera confianza y aumenta la tolerancia a errores. La otra característica inteligente de Seal es que la lógica de control de acceso está escrita como Move smart contracts on-chain. Los desarrolladores pueden definir reglas claras: por ejemplo, solo los usuarios que posean un determinado NFT o que hayan pagado una tarifa pueden acceder a ciertos datos. Esta transparencia y verificabilidad distinguen a Seal de los sistemas de acceso centralizado tradicionales. Cuando un usuario o una aplicación desean descifrar un secreto, envían una solicitud a los servidores clave. Estos servidores comprueban las reglas de la cadena. Solo si se cumplen las condiciones, publican sus fragmentos clave. El descifrado propiamente dicho se produce en el dispositivo cliente, por lo que los servidores de claves nunca tocan los datos originales. Seal puede proteger los datos almacenados en cualquier lugar: en Walrus, otras redes descentralizadas o incluso en nubes centralizadas. Esto lo hace ideal para la mensajería segura, los datos privados de los usuarios, la protección de contenido de pago, la votación confidencial y mucho más. Nautilus: Hacer que la computación fuera de cadena sea verificable en cadena Las cadenas de bloques no son excelentes para tareas complejas o que requieren muchos recursos. Hacerlas en cadena es lento, caro y compromete la privacidad. Las soluciones como Layer 2 o Oracles ayudan, pero Nautilus explora un camino diferente: posibilitar una computación fiable fuera de la cadena. Nautilus utiliza una solución basada en hardware denominada Trusted Execution Environments (TEEs). Piense en un TEE como una zona segura y aislada dentro de una CPU. El código y los datos de esta zona están protegidos del resto del sistema, incluido el propio sistema operativo. El flujo de trabajo básico es el siguiente: Un desarrollador implementa una tarea computacional (por ejemplo, modelos financieros, inferencia de IA, lógica de juego) en un TEE que controla. Cuando finaliza la tarea, el TEE produce una certificación criptográfica, una especie de «recibo» a prueba de manipulaciones que demuestra: la tarea se ejecutó en un TEE el código no fue alterado el proceso se completó correctamente. Esta certificación y el resultado se someten a un contrato inteligente de Move en Sui. El contrato verifica la certificación (por ejemplo, la validez de la firma y el hash del código). Solo si se aprueba la verificación, el contrato acepta el resultado y continúa con las acciones en cadena. Nautilus une la computación de alto rendimiento fuera de la cadena con la verificabilidad y la confianza dentro de la cadena, sin exponer detalles confidenciales. Nautilus en acción: el caso de Bluefin Un ejemplo concreto es Bluefin, una plataforma descentralizada de comercio de perpetuos. La mayoría de las plataformas de negociación de alto rendimiento se enfrentan a un dilema: mantener las carteras de pedidos totalmente integradas en la cadena ofrece transparencia, pero es lento y caro; moverlas fuera de la cadena mejora la velocidad, pero introduce problemas de confianza. Bluefin usa Nautilus para cerrar esta brecha: • La comparación de pedidos se realiza dentro de un TEE, lo que garantiza un procesamiento seguro y aislado. • Nautilus proporciona una prueba criptográfica de que la lógica coincidente se ejecutó correctamente. • Las pruebas y los resultados se envían en cadena, donde los contratos inteligentes los verifican antes de ejecutar la liquidación. Este enfoque permite a Bluefin ofrecer una combinación rápida fuera de la cadena con garantías de confianza dentro de la cadena, lo que lo hace viable para las operaciones con derivados de DeFi, que requieren un alto rendimiento, como las de DeFi. Por supuesto, esto hace que parte de la confianza pase del consenso puro sobre la cadena de bloques a centrarse en el hardware y la implementación de TEE.
0 - Dentro del quiosco de Sui: cómo crear mercados NFT segurosArtículoHaGiang139May 01, 2025
¿Qué es el quiosco de Sui? Kiosk es un módulo de contrato inteligente nativo de la cadena de bloques Sui, diseñado para estandarizar y simplificar la forma en que se almacenan, administran y comercializan las NFT. Actúa como un escaparate programable de NFT, ideal para los desarrolladores que quieren evitar tener que reinventar la rueda en cada proyecto relacionado con los NFT. Ya sea que estés creando un mercado, un intercambio de activos de juegos o una galería de objetos coleccionables digitales, Kiosk te ofrece componentes básicos seguros y personalizables. 🛠️ Características principales de Kiosk 📦 Almacenamiento y visualización de NFT: los usuarios pueden depositar NFT en Kiosk Smart Contracts para almacenarlos, mostrarlos o intercambiarlos 🔐 Transferencia de propiedad segura: todos los flujos de compra/venta están estandarizados y son verificables: ¡adiós a las permutas sospechosas 👋 🎛️ Permisos detallados: Kiosk permite a los desarrolladores definir exactamente quién puede hacer qué con cada NFT. 📈 Extensibilidad para desarrolladores: incluye subastas, anuncios por lotes, paquetes y mucho más. 🤔 ¿Por qué construir con Kiosk? Imagina que estás lanzando una aplicación NFT. Es probable que necesites una forma para que los usuarios almacenen los activos de forma segura. Una forma de listar y comprar activos. Kiosk se encarga de todo eso por ti. En lugar de escribir todos estos flujos desde cero (y correr el riesgo de que se produzcan errores 🐛 o vulnerabilidades), utilizas la API de Kiosk, que ha sido probada con éxito. 🧪 Ejemplo de aplicación: construir con Kiosk Veamos un ejemplo real. Crearás un módulo NFT básico y, a continuación, utilizarás el módulo Kiosk para depositarlo, ponerlo en venta y permitir que otros lo compren. Desglose del código paso a paso module 0xNFT::simple_nft { use sui::object::{UID}; use sui::tx_context::TxContext; struct SimpleNFT has key { id: UID, name: String, description: String, url: String, } public entry fun mint( name: String, description: String, url: String, ctx: &mut TxContext ): SimpleNFT { SimpleNFT { id: UID::new(ctx), name, description, url, } } } Comandos (en la CLI) Compile your package sui move build Deploy to network sui client publish --gas-budget 10000 Mint NFT sui client call --function mint --module simple_nft \ --args "My NFT" "Desc" "https://example.com/img.png" --gas-budget 1000 Initialize Kiosk sui client call --function init_kiosk --module kiosk_example --gas-budget 1000 Deposit NFT to Kiosk sui client call --function deposit_nft --module kiosk_example \ --args --gas-budget 1000 List for sale sui client call --function list_nft_for_sale --module kiosk_example \ --args 100 --gas-budget 1000 Purchase NFT sui client call --function purchase_nft --module kiosk_example \ --args --gas-budget 1000 Kiosk es una de las primitivas más poderosas del ecosistema Sui para los desarrolladores de NFT. Abstrae la lógica repetitiva e inyecta seguridad y modularidad en tu pila de aplicaciones. Con solo unas pocas líneas de código, estás creando flujos completos de mercado de NFT listos para la producción y probados.
2 - Lenguaje de programación Move: la historia detrásArtículoMiniBob406Apr 30, 2025
En el panorama en constante evolución de la tecnología blockchain, los lenguajes de programación de contratos inteligentes se han convertido en la columna vertebral de las aplicaciones descentralizadas (dApps). Entre ellos, Move se ha convertido en una innovación revolucionaria, que ofrece características únicas que lo diferencian de los lenguajes tradicionales como Solidity o Vyper. Diseñado teniendo en cuenta la seguridad y la escalabilidad, Move se creó para abordar muchas de las vulnerabilidades e ineficiencias inherentes a los ecosistemas de cadenas de bloques anteriores. Este artículo profundiza en los orígenes, las características y el impacto del lenguaje de programación Move, y explora su recorrido desde su creación hasta convertirse en una de las herramientas más prometedoras para construir sistemas descentralizados sólidos. Los orígenes de Move: una solución a los desafíos de la cadena de bloques El lenguaje de programación Move fue introducido por primera vez por Meta (anteriormente Facebook) como parte de su ambicioso proyecto Diem (inicialmente llamado Libra). Diem tenía como objetivo crear una moneda digital global y una infraestructura financiera impulsada por la tecnología blockchain. Sin embargo, el equipo se dio cuenta rápidamente de que los lenguajes de contratos inteligentes existentes eran insuficientes para su visión. Los lenguajes tradicionales a menudo carecían de mecanismos para prevenir las vulnerabilidades más comunes, como los ataques de reingreso, los desbordamientos de números enteros y la duplicación no autorizada de activos. Estos problemas ya habían causado daños importantes en otros ecosistemas, sobre todo el infame hackeo de la DAO a Ethereum. Para superar estos desafíos, el equipo de ingeniería de Meta desarrolló Move, un nuevo lenguaje diseñado específicamente para la programación orientada a los recursos. A diferencia de los lenguajes de programación convencionales, Move trata los activos digitales como recursos de primera clase, lo que garantiza que no puedan duplicarse, eliminarse involuntariamente o utilizarse indebidamente. Este enfoque se inspiró en la lógica lineal, un marco matemático que impone reglas estrictas de propiedad de los recursos. Al integrar estos principios en el núcleo del lenguaje, Move introdujo un cambio de paradigma en la forma en que los desarrolladores interactúan con los activos digitales en la cadena de bloques. Aunque el proyecto Diem finalmente se archivó debido al escrutinio regulatorio, Move encontró una nueva vida en proyectos independientes de cadenas de bloques como Aptos y Sui. Estas plataformas adoptaron Move como su principal lenguaje de contratos inteligentes, reconociendo su potencial para revolucionar la forma en que se crean y protegen las aplicaciones descentralizadas. Características clave de Move: por qué se destaca 1. Programación orientada a los recursos Una de las características que definen a Move es su enfoque en la programación orientada a los recursos. En Move, los activos digitales, como los tokens, los NFT o incluso los objetos personalizados, se tratan como recursos que siguen estrictas normas de propiedad. Una vez creado, un recurso no se puede copiar ni destruir a menos que su módulo lo permita explícitamente. Esto garantiza que las operaciones críticas relacionadas con los activos, como las transferencias o las actualizaciones de estado, se realicen de forma segura. Por ejemplo, consideremos una función simple de transferencia de fichas escrita en Move: ejemplos de módulos: :token { usa sui: :object:: {Self, UID}; usa sui: :transfer; struct Token tiene una clave, store { id: UID, valor: u64, } public fun mint (ctx: &mut txContext, valor: u64): Token { Símbolo { id: object: :new (ctx), valor, } } public fun transfer_token (token: token, destinatario: dirección) { transfer: :public_transfer (token, destinatario); } } Aquí, la Token estructura representa un recurso que solo se puede transferir mediante la función public_transfer. Cualquier intento de duplicar o manipular el token fuera de esta función provocaría un error de compilación. Este diseño elimina clases enteras de errores y vulnerabilidades que suelen aparecer en otros lenguajes. 2. Modularidad y encapsulación Move promueve el diseño modular, lo que permite a los desarrolladores encapsular la funcionalidad en módulos independientes. Cada módulo define sus propios tipos, funciones y controles de acceso, lo que garantiza una separación clara entre los diferentes componentes de un contrato inteligente. Por ejemplo, un desarrollador puede crear módulos separados para la creación de tokens, los pares de negociación y la lógica de gobernanza. Esta modularidad mejora la legibilidad, el mantenimiento y la reutilización del código. 3. Soporte de verificación formal Otra característica destacada de Move es su compatibilidad con la verificación formal, un proceso que se utiliza para demostrar matemáticamente la exactitud de un programa. La verificación formal ayuda a identificar errores sutiles y casos extremos que pueden no detectarse con los métodos de prueba tradicionales. Si bien no todos los proyectos basados en Move requieren una verificación formal, la estructura del lenguaje facilita la aplicación de esta técnica cuando es necesaria. 4. Diseño centrado en objetos (mejoras específicas para Sui) En la cadena de bloques Sui, Move se ha mejorado aún más con un modelo centrado en objetos. Cada recurso de Sui Move tiene un identificador único a nivel mundial (UID), que permite la referencia directa y la interacción con los objetos. Este diseño simplifica los flujos de trabajo complejos, como la administración de las NFT o el seguimiento de los datos específicos de los usuarios, a la vez que mantiene un alto rendimiento y escalabilidad. Aplicaciones de Move en el mundo real Desde su adopción por Aptos y Sui, Move se ha utilizado para crear una amplia gama de aplicaciones descentralizadas. Algunos ejemplos notables incluyen: 1. Protocolos de financiación descentralizada (DeFi) El fuerte énfasis de Move en la seguridad lo hace ideal para las aplicaciones de DeFi, donde están en juego activos por valor de miles de millones de dólares. Proyectos como Cetus, una bolsa descentralizada (DEX) basada en SUI, aprovechan la programación orientada a los recursos de Move para implementar funciones de negociación avanzadas y, al mismo tiempo, minimizar los riesgos asociados con la manipulación de activos. 2. Tokens no fungibles (NFT) Los mercados de NFT se benefician enormemente de la capacidad de Move para definir y gestionar activos digitales únicos. Los desarrolladores pueden crear estándares de NFT sofisticados con un control granular sobre la propiedad, las regalías y los metadatos. Además, las mejoras centradas en los objetos de Sui permiten una integración perfecta de las NFT dinámicas, que pueden evolucionar en función de condiciones predefinidas. 3. Plataformas de juegos y metaverso Los juegos basados en la cadena de bloques requieren un manejo eficiente de los activos del juego, las interacciones de los jugadores y las actualizaciones en tiempo real. La arquitectura modular y la ejecución de baja latencia de Move lo hacen ideal para crear experiencias de juego envolventes. Plataformas como Blockus, un ecosistema de juegos de Web3, utilizan Move para impulsar sus economías y juegos descentralizados. Comparando Move con otros lenguajes de contratos inteligentes Si bien Move comparte algunas similitudes con otros lenguajes de contratos inteligentes, sus características únicas le dan una ventaja competitiva: Solidity: Como idioma principal de Ethereum, Solidity es ampliamente adoptado, pero adolece de problemas heredados, como la vulnerabilidad a los ataques de reentrada. Move aborda estas debilidades mediante su modelo orientado a los recursos y una seguridad tipográfica más estricta. Rust (usado en Solana): Rust ofrece un rendimiento y una seguridad de memoria excelentes, pero carece del soporte nativo de Move para la administración de recursos y la verificación formal. Además, la pronunciada curva de aprendizaje de Rust puede disuadir a los recién llegados en comparación con la sintaxis más intuitiva de Move. Clarity (utilizada en Stacks): Clarity hace hincapié en la transparencia y la previsibilidad, pero opera dentro de un ámbito limitado vinculado al ecosistema de Bitcoin. Move, por otro lado, admite casos de uso más amplios en múltiples cadenas de bloques. El futuro de Move: adopción y evolución A medida que la tecnología blockchain siga madurando, la demanda de lenguajes de contratos inteligentes seguros y escalables no hará más que crecer. Move está a punto de desempeñar un papel fundamental en la configuración de la próxima generación de aplicaciones descentralizadas, gracias a su diseño innovador y al creciente apoyo de la comunidad. Proyectos como Aptos y Sui están invirtiendo activamente en educación, herramientas e infraestructura para desarrolladores para acelerar la adopción de Move. Iniciativas como la plataforma Move eLearning ofrecen tutoriales y recursos completos para los aspirantes a desarrolladores, lo que reduce las barreras de acceso. Además, las colaboraciones con instituciones académicas y líderes del sector están impulsando la investigación sobre temas avanzados como la verificación formal y la interoperabilidad entre cadenas. De cara al futuro, cabe esperar que Move vaya más allá de sus casos de uso actuales e impulse todo tipo de aplicaciones, desde soluciones de cadena de suministro de nivel empresarial hasta redes sociales descentralizadas. Su adaptabilidad y solidez garantizan que siga siendo relevante en un ecosistema de cadenas de bloques cada vez más diverso e interconectado.
3 - Es la hora del zk. Pongámonos raros ^^Artículoharry phan396Apr 30, 2025
Oye «Sé una cosa, pero no te diré qué y aun así me creerás. » ✨ Imagina esto: ¡ Demuestra que trabaja en una determinada empresa. ✅ Sin revelar tu correo electrónico. ✅ Sin dañar tu identidad de Web2. ✅ Totalmente verificable en cadena. Ese es el poder de las pruebas de conocimiento cero (pruebas zk) y ya no es necesario tener un doctorado en criptografía para empezar a crear con ellas. Bienvenido al mundo de zkApps: aplicaciones impulsadas por la magia criptográfica, pero diseñadas con herramientas que dan la misma sensación que escribir código normal. ¿Qué es una ZkApp (aplicación de conocimiento cero)? Una zkApp es una aplicación en la que los usuarios puedenprobar algo sobre sus datos privadossin revelar los datos en sí. Piense en ello como flexionar recibos... sin mostrar su cartera. Estas aplicaciones permiten funciones con las que a menudo solo soñamos, como verificar la identidad de alguien sin revelar su nombre o permitir a los usuarios votar en cadena sin revelar su voto real. En el ecosistema Sui, las zkApps adquieren un potencial adicional. Usan sus secretos fuera de la cadena con la lógica interna, y utilizan herramientas comoSP1 zKVMySoundness Layerpara hacer que la generación de pruebas y la verificación sean más prácticas que nunca. Tradicionalmente,escribir un circuito zk requería conocimientos criptográficos y semanas de efectivort. Pero los zKVM como SP1, Risc0 y Nexus han cambiado las reglas del juego. Estas máquinas virtuales permiten a los desarrolladores expresar su lógica en lenguajes de programación normales, generaruna prueba zkpara el resultado y enviarlo para su verificación en cadena. Esta abstracción no solo acelera el desarrollo, sino que amplía la capacidad de crear zkApps. Si puedes escribir lógica en Rust, puedes construir una ZkApp. Y si usasSoundness Layer, puedes verificarlo en Sui. #ZkDomain: demostrar la propiedad del correo electrónico sin exposición Consideremos un escenario común en el que una DAO quiere enviar tokens desde el aire a los empleados de una empresa específica. Pero en lugar de recopilar los correos electrónicos de los usuarios y verificarlos manualmente, lo que expone la identidad de Web2 y pone en riesgo la privacidad de los usuarios, queremos que los usuariosdemuestraque son propietarios de un correo electrónico en* @soundness .xyz*, sin revelar nunca la dirección completa. Aquí es donde entra en juego la magia del mundo real de zk. Si tienes acceso al correo electrónico de una empresa que utilizaGoogle Workspace, puedes autenticarte medianteOpenID Connect (OIDC) y recibir unJWT (JSON Web Token) firmado por Google. Este token contiene metadatos, incluido tu correo electrónico. Ahora, en lugar de enviar ese JWT a la DAO,generas una prueba zk que diga: «Tengo un JWT válido emitido por Googleymi correo electrónico termina en @soundness .xyz». Esa prueba se verifica en cadena. Nadie ve tu correo electrónico real. La DAO solo ve que se ha aprobado una prueba. Acceso concedido. Toda la lógica de verificación (el análisis de JWT, la validación de firmas y la verificación de dominios) se ejecuta dentro de un programa zKVM escrito en Rust y compilado por el SP1. Puedes ver la implementación completa aquí: 👉 Ejemplo de zkDomain para el SP1 #![no_main] sp1_zkvm::entrypoint!(main); use lib::{split_email, split_jwt, pem_to_der}; use rsa::{pkcs8::DecodePublicKey, Pkcs1v15Sign, RsaPublicKey}; use sha2_v0_10_8::{Digest, Sha256}; pub fn main() { // Read input values: JWT token, RSA public key, and the expected domain let token = sp1_zkvm::io::read::(); let rsa_public_key = sp1_zkvm::io::read::(); let domain = sp1_zkvm::io::read::(); // Commit the domain to the zk proof (so it’s publicly known) sp1_zkvm::io::commit(&domain); // Split the JWT into its components: header, payload, and signature let (header, payload, signature) = split_jwt(&token) .expect("Failed to decode JWT"); // Panic if JWT parsing fails // Convert the PEM public key into DER format for RSA verification let pk_der = pem_to_der(&rsa_public_key); let public_key = RsaPublicKey::from_public_key_der(&pk_der).unwrap(); // Reconstruct the signing input (header + payload) as a string let signing_input = format!( "{}.{}", token.split('.').collect::>()[0], // First part: header token.split('.').collect::>()[1] // Second part: payload ); // Hash the signing input using SHA256 let mut hasher = Sha256::new(); hasher.update(signing_input); let hashed_msg = hasher.finalize(); // Verify the JWT signature using the provided RSA public key let verification_result = match public_key.verify(Pkcs1v15Sign::new::(), &hashed_msg, &signature) { Ok(_) => true, // Signature is valid Err(_) => false, // Signature is invalid }; // Commit the verification result (proof that the JWT is authentic) sp1_zkvm::io::commit(&verification_result); // Extract and split the email address from the JWT payload let email_parts = split_email(payload.get("email").unwrap().to_string()).unwrap(); // Check if the email domain matches the expected domain let verified = email_parts.domain == domain; // Commit the verification result (proof that the email domain is correct) sp1_zkvm::io::commit(&verified); } Solo el dominio y si el JWT era válido o no. Eso es todo. El correo electrónico completo del usuario, el JWT original y cualquier otra información de identificación personal permanecen ocultos y sellados criptográficamente dentro de la prueba. ##Verificación en cadena: de zKVM a Move Por supuesto, generar la prueba es solo una cara de la moneda. La verdadera utilidad se activa cuando puedes verificar esa prueba en cadena y tomar medidas en función de ella. Aquí es donde laSoundness Layercambia las reglas del juego. Creada para Sui, actúa como una capa de verificación zk que puede procesar las pruebas generadas por el SP1 y convertirlas al formato Groth16, que Sui admite de forma nativa. No necesita meterse con las primitivas criptográficas. Solo tienes que escribir un contrato inteligente en Move, pasar la prueba y las entradas públicas (como el dominio esperado) y dejar que la lógica del verificador se encargue del resto. Esto significa que tu contrato inteligente DAO ahora puede controlar los lanzamientos aéreos en función de la propiedad del dominio del correo electrónico, sin tocar nunca datos confidenciales. Soundness Layer se encarga de la verificación. Su contrato inteligente se encarga de la lógica. El resto es mágico. Obtén más información sobre Soundness Layer aquí: 🔗 soundness.xyz/blog/soundness-layer Puede crear flujos de autenticación sin contraseñas. Puede diseñar sistemas de votación que garanticen el anonimato. Puedes restringir el acceso a las DAO, los eventos o las recompensas en función de criterios que permanecen completamente privados. Y lo que es más importante, puedes hacer todo esto conRust + Sui + SP1 + Soundness Layer, sin escribir ni una sola restricción criptográfica a mano. Ya no hablamos del zk teórico. Estamos hablando de los zk que puedes enviar. Porque la privacidad no es solo una característica, es una base. Y con zk, por fin es componible.
2
Publicaciones
303- P&R expertosOwen15May 31, 2025
Error de verificación de tipos al usar una estructura personalizada como parámetro de tipo en coin: :Coin de Sui Move?
Pregunta: Me encuentro con un error de verificación de tipo en mi código Sui Move que no entiendo. Esta es una versión simplificada de mi código: module my_module::mymodule { use sui::coin; use sui::wallets; struct MyCoin has drop {} public fun create_coin(): coin::Coin { coin::mint(1000) } } Cuando intento compilar, aparece el siguiente error: Invalid type parameter instantiation. Expected type 'phantom type T' but found 'MyCoin' ¿Qué estoy haciendo mal? ¿Por qué no puedo usarlo MyCoincomo parámetro de tipo para coin::Coineste problema de verificación de tipos y cómo puedo solucionarlo?
- Sui
- Architecture
00 - Artículo0xduckmove263May 30, 2025
Codificación BCS en Sui: qué es y por qué es importante
Si te estás basando en Sui o jugando con Move, es probable que hayas escuchado el término BCS por ahí. Es la abreviatura de la máquina formateadora de serialización canónica binaria creada originalmente para la cadena de bloques Diem, y ahora es la piedra angular de los ecosistemas basados en Move, como Sui, Aptos, Starcoin y 0L. Así que sí, es mejor que te sientas cómodo con ello si realmente quieres construir en este espacio. ¿Qué es BCS? La serialización canónica binaria (BCS) es un formato que se utiliza para serializar (codificar) y deserializar (decodificar) datos estructurados en bytes. Verás que se usa cuando: Codificar las transacciones antes de firmarlas. Emitir o analizar eventos desde la cadena de bloques. Interactuar con Move Smart Contracts fuera de la cadena a través de JavaScript. Sin embargo, BCS no incluye información de tipos en los bytes. Esto significa que debes conocer la estructura con antelación al decodificar, a diferencia de los formatos como JSON o Protocol Buffers, que se describen más por sí mismos. Características principales de BCS No hay ningún tipo de metadatos La salida serializada no contiene sugerencias sobre los tipos de campos. Debes saber a qué te enfrentas cuando decodificas. Serialización dependiente del pedido Las estructuras se codifican en el orden exacto de sus campos. Cambie el orden y la deserialización se interrumpirá. Esta es la razón por la que las funciones peel_* de Move deben coincidir con el diseño 1:1. Tipo genérico En una estructura como: struct BCSObject has drop, copy { id: ID, owner: address, meta: Metadata, generic: T } Solo puede deserializar de forma fiable hasta el metacampo. Los tipos genéricos estropean el análisis del BCS, así que póngalos siempre en último lugar si desea que sus datos se decodifiquen de forma segura. Uso de BCS en JavaScript Gracias a la biblioteca @mysten /bcs, puedes trabajar con BCS en JS como un profesional. npm i @mysten/bcs y un ejemplo básico: import { BCS, getSuiMoveConfig } from "@mysten/bcs"; const bcs = new BCS(getSuiMoveConfig()); const ser = bcs.ser(BCS.U16, 10); console.log(ser.toBytes()); // [0x0a, 0x00] const des = bcs.de(BCS.U16, ser.toBytes()); console.log(des); // 10 También puede serializar vectores y cadenas: bcs.ser("vector", [1, 2, 3, 4]); // 04 01 02 03 04 bcs.ser(BCS.STRING, "test string"); // 0b7465737420737472696e67 Registro de tipos personalizados Supongamos que tienes las siguientes estructuras de movimiento: struct Metadata has drop, copy { name: std::ascii::String } struct BCSObject has drop, copy { id: ID, owner: address, meta: Metadata } Puedes registrarlos así en JS: bcs.registerStructType("Metadata", { name: BCS.STRING, }); bcs.registerStructType("BCSObject", { id: BCS.ADDRESS, owner: BCS.ADDRESS, meta: "Metadata", }); Ejemplo de serialización y deserialización Serialización de JavaScript: const bytes = bcs .ser("BCSObject", { id: "0x0000000000000000000000000000000000000005", owner: "0x000000000000000000000000000000000000000a", meta: { name: "aaa" } }) .toString("hex"); console.log("Hex:", bytes); La salida puede ser: 0x0000000000000000000000000000000000000005000000000000000000000000000000000000000a03616161 Esto ahora puede transferirse a un contrato de Move o incluso probarse manualmente en la CLI de Sui. El BCS puede parecer de bajo nivel y con muchos bytes, pero una vez que comprendas cómo codifica los datos, comprenderás mejor cómo funcionan realmente los contratos inteligentes de Move y cómo conectar sistemas on-chain ↔ off-chain de forma segura. Y si estás depurando los bytes del BCS en Sui Explorer (como el que se muestra a continuación): Codificación BCS La serialización canónica binaria, o BCS, es un formato de serialización desarrollado en el contexto de la cadena de bloques Diem, y ahora se usa ampliamente en la mayoría de las cadenas de bloques basadas en Move (Sui, Starcoin, Aptos, 0L). El BCS no solo se usa en la máquina virtual Move, sino que también se usa en la codificación de transacciones y eventos, como la serialización de las transacciones antes de firmarlas o el análisis de datos de eventos. Saber cómo funciona BCS es crucial si quieres entender cómo funciona Move a un nivel más profundo y convertirte en un experto en Move. Vamos a sumergirnos. Especificaciones y propiedades del BCS Hay algunas propiedades de alto nivel de la codificación BCS que conviene tener en cuenta a medida que avancemos en el resto de la lección: El BCS es un formato de serialización de datos en el que los bytes de salida resultantes no contienen ningún tipo de información; por ello, la parte que reciba los bytes codificados necesitará saber cómo deserializar los datos En BCS no hay estructuras (ya que no hay tipos); la estructura simplemente define el orden en el que se serializan los campos Los tipos de contenedores se ignoran, por lo que OuterType y UnnestedType tendrán la misma representación de BCS: estructura: outerType { propietario: innerType } estructura InnerType { dirección: dirección } estructura UnnestedType { dirección: dirección } Los tipos que contienen los campos de tipo genérico se pueden analizar hasta el primer campo de tipo genérico. Por lo tanto, es una buena práctica poner los campos de tipo genérico en último lugar si se trata de un tipo personalizado que se va a ser/eliminar. struct bcSObject tiene drop, copy { id: ID, propietario: dirección, meta: metadatos, genérico: T } En este ejemplo, podemos deserializar todo hasta el metacampo. Los tipos primitivos, como las entradas sin signo, están codificados en formato Little Endian El vector se serializa con una longitud ULEB128 (con una longitud máxima de hasta u32) seguida del contenido del vector. La especificación BCS completa se encuentra en el repositorio BCS. Uso de la biblioteca de JavaScript @mysten /bcs Instalación La biblioteca que necesitará instalar para esta parte es la biblioteca @mysten /bcs. Puedes instalarla escribiendo en el directorio raíz de un proyecto de nodo: npm i @mysten /bcs Ejemplo básico Utilicemos primero la biblioteca de JavaScript para serializar y deserializar algunos tipos de datos simples: importar {BCS, getSuiMoveConfig} desde "@mysten /bcs «; //inicializa el serializador con las configuraciones predeterminadas de Sui Move const bcs = new BCS (getSuiMoveConfig ()); //Definir algunos tipos de datos de prueba entero constante = 10; matriz constante = [1, 2, 3, 4]; const string = «cadena de prueba» //usa bcs.ser () para serializar los datos const ser_integer = bcs.ser (BCS.U16, entero); const ser_array = bcs.ser («vector «, matriz); const ser_string = bcs.ser (BCS.STRING, cadena); //usa bcs.de () para deserializar datos const de_integer = bcs.de (BCS.U16, SER_Integer.toBytes ()); const de_array = bcs.de («vector «, ser_Array.toBytes ()); const de_string = bcs.de (BCS.STRING, ser_string.tobytes ()); Podemos inicializar la instancia del serializador con la configuración predeterminada integrada para Sui Move usando la sintaxis anterior, new BCS (getSuiMoveConfig ()). Hay enumeraciones integradas que se pueden usar para los tipos de Sui Move, como BCS.U16, BCS.STRING, etc. Para los tipos genéricos, se pueden definir usando la misma sintaxis que en Sui Move, como el vector del ejemplo anterior. Echemos un vistazo más de cerca a los campos serializados y deserializados: las entradas son hexadecimales mendianos 0a00 10 el primer elemento de un vector indica la longitud total, entonces son los elementos que están en el vector 0401020304 1,2,3,4 las cadenas son solo vectores de u8, con el primer elemento igual a la longitud de la cadena 0b7465737420737472696e67 cadena de prueba Escriba el registro Podemos registrar los tipos personalizados con los que trabajaremos usando la siguiente sintaxis: importar {BCS, getSuiMoveConfig} desde "@mysten /bcs «; const bcs = new BCS (getSuiMoveConfig ()); //Registrar el tipo de metadatos bcs.registerStructType («Metadatos», { nombre: BCS.STRING, }); //Lo mismo para el objeto principal que pretendemos leer bcs.registerStructType («bcsObject», { //BCS.ADDRESS se usa tanto para tipos de ID como para tipos de direcciones id: BCS.ADDRESS, propietario: BCS.ADDRESS, meta: «Metadatos», }); Uso de bcs en Sui Smart Contracts Continuemos con nuestro ejemplo de arriba con las estructuras. Definición de estructura Empezamos con las definiciones de estructura correspondientes en el contrato Sui Move. { //.. estructura Los metadatos han eliminado, copiado { nombre: std: :ascii: :String } struct bcSObject ha caído, copia { id: ID, propietario: dirección, meta: Metadatos } //.. } Deserialización Ahora, escribamos la función para deserializar un objeto en un contrato Sui. public fun object_from_bytes (bcs_bytes: vector): bcSObject { //Inicializa la instancia de bcs bytes let bcs = bcs: :new (bcs_bytes); //Usa peel_*funciones para eliminar los valores de los bytes serializados. //¡El orden tiene que ser el mismo que usamos en la serialización! let (id, owner, meta) = ( bcs: :peel_address (&mut bcs), bcs: :peel_address (&mut bcs), bcs: :peel_vec_u8 (&mut bcs) ); //Empaquete una estructura BCSObject con los resultados de la serialización BCSObject {id: object: :id_from_address (id), owner, meta: Metadata {name: std: :ascii: :string (meta)}} Los distintos métodos peel_* del módulo bcs de Sui Frame se utilizan para «separar» cada campo individual de los bytes serializados de BCS. Tenga en cuenta que el orden en que eliminamos los campos debe ser exactamente el mismo que el orden de los campos en la definición de la estructura. Cuestionario: ¿Por qué los resultados de las dos primeras llamadas a peel_address en el mismo objeto bcs no son los mismos? Observa también cómo convertimos los tipos de address a id y de vector a std: :ascii: :string con funciones auxiliares. Cuestionario: ¿Qué pasaría si BSCobject tuviera un tipo de UID en lugar de un tipo de ID? Ejemplo completo de Ser/De Encuentra los códigos de muestra completos de JavaScript y Sui Move en la carpeta example_projects. Primero, serializamos un objeto de prueba usando el programa JavaScript: //Construimos un objeto de prueba para serializarlo, ten en cuenta que podemos especificar el formato de la salida en hexadecimal let _bytes = bcs .ser («bcsObject», { id: «0x00000000000000000000000000000005", propietario: «0x0000000000000000000000000000000a», meta: {nombre: «aaa"} }) .toString («hexadecimal»); Queremos que la salida del escritor BCS esté en formato hexadecimal esta vez, que se puede especificar como se indica arriba. Añada el prefijo 0x a la cadena hexadecimal del resultado de la serialización y expórtela a una variable de entorno: export Object_hexstring=0x000000000000000000000000000000000005000000000000000000000000000000000000000000000000000A03616161 Ahora podemos ejecutar las pruebas unitarias de Move asociadas para comprobar que son correctas: Una prueba de movimiento adecuada Deberías ver esto en la consola: CONSTRUYENDO bcs_move Ejecutando pruebas unitarias de Move [PASS] 0x0: :bcs_object: :test_deserialization Resultado de la prueba: OK. Total de pruebas: 1; superadas: 1; fallidas: 0 O podemos publicar el módulo (y exportar el PACKAGE_ID) y llamar al método emit_object utilizando la cadena hexagonal serializada de BCS anterior: sui client call --function emit_object --module bcs_object --package $PACKAGE_ID --args $OBJECT_HEXSTRING A continuación, podemos comprobar la pestaña Eventos de la transacción en el explorador Sui para comprobar que hemos emitido el BCSObject deserializado correctamente:
- Sui
- SDKs and Developer Tools
1 - DiscusiónDRAMA32May 30, 2025
¿Cómo administrar el acceso a la DApp en SUI Wallet sin una función de revocación?
He estado usando la billetera SUI y me he dado cuenta de que no hay una opción para revocar el acceso a las dApps como ocurre con las cadenas EVM. ¿Cómo puedo evitar que las dApps tengan acceso perpetuo a mi monedero si la extensión de Chrome no cuenta con un sistema de revocación claro?
- Sui
02 +10
P&R expertosMay 29, 2025¿Por qué BCS requiere un orden de campo exacto para la deserialización cuando las estructuras Move tienen campos con nombre?
¿Por qué BCS requiere un orden exacto de los campos para la deserialización cuando las estructuras de Move tienen campos con nombre? He profundizado en la codificación y decodificación de BCS en Move, especialmente para la comunicación entre cadenas y el procesamiento de datos fuera de la cadena. Mientras estudiaba los ejemplos de la documentación de Sui Move, me encontré con algunos comportamientos que parecen contradictorios y estoy intentando entender las decisiones de diseño subyacentes. Según la especificación de BCS, «no hay estructuras en BCS (ya que no hay tipos); la estructura simplemente define el orden en el que se serializan los campos». Esto significa que, al deserializar, debemos usar peel_*las funciones exactamente en el mismo orden en que se definieron los campos de estructura. Mis preguntas específicas: Justificación del diseño: ¿Por qué BCS exige que los campos coincidan exactamente en el orden de los campos cuando las estructuras de movimiento tienen campos con nombre? ¿No sería más sólido serializar los nombres de los campos junto con los valores, de forma similar a JSON u otros formatos autodescriptivos? Interacción de tipos genéricos: Los documentos mencionan que «los tipos que contienen campos de tipo genérico se pueden analizar hasta el primer campo de tipo genérico». Considera esta estructura: struct ComplexObject has drop, copy { id: ID, owner: address, metadata: Metadata, generic_data: T, more_metadata: String, another_generic: U } ¿Cómo funciona exactamente la deserialización parcial aquí? ¿Puedo deserializar hasta more_metadata e ignorar ambos campos genéricos, o el primer campo genérico (generic_data) bloquea por completo la deserialización posterior? Coherencia entre idiomas: al utilizar la biblioteca JavaScript @mysten /bcs para serializar los datos que consumirán los contratos de Move, qué ocurre si: ¿Reordeno accidentalmente los campos del objeto de JavaScript? ¿La definición de la estructura Move cambia el orden de los campos en una actualización de contrato? ¿Tengo estructuras anidadas con sus propios parámetros genéricos? Implicaciones prácticas: En los sistemas de producción, ¿cómo gestionan los equipos la evolución del esquema BCS? ¿Versionan sus esquemas de BCS o esperan que el orden de los campos de las estructuras sea inmutable una vez implementados?
- Sui
- Move
51- DiscusiónMay 29, 2025
¿Cómo encontrar el identificador del objeto de capitalización de tesorería para un tipo de moneda?
Quiero saber cómo puedo obtener el identificador del objeto del límite de tesorería de una moneda, solo con el nombre del tipo de moneda. Actualmente, estoy buscando el objeto de metadatos y comprobando sus transacciones anteriores para encontrar el objeto de límite de tesorería, pero este método parece ineficaz. Estoy buscando una forma más fácil y eficiente de determinar si una moneda está congelada utilizando el nombre del tipo de moneda. ¿Alguna sugerencia?
- Sui
04 - DiscusiónTheoremus175May 29, 2025
¿Cómo copiar fácilmente una dirección de billetera que no se puede copiar?
He tenido problemas para copiar la dirección de mi monedero porque no se puede copiar directamente. No estoy seguro de si hay una forma rápida o una función oculta que me falta. ¿Alguien puede guiarme sobre cómo hacerlo?
- Sui
02 - ArtículoVens.sui134May 29, 2025
Hackeo del protocolo Cetus: el mayor exploit de DeFi en Sui
En mayo de 2025, el mundo de las DeFi se vio sacudido por una de las brechas de seguridad más importantes de la historia reciente. Cetus Protocol, uno de los principales protocolos de intercambio descentralizado (DEX) y liquidez de la cadena de bloques Sui, fue víctima de un sofisticado hackeo que provocó pérdidas que superaron los 200 millones de dólares. Este incidente no solo conmocionó a la comunidad de DeFi, sino que también generó serias preocupaciones sobre la seguridad de los contratos inteligentes y la solidez de los protocolos basados en cadenas de bloques emergentes como Sui. Cetus Protocol se había establecido como el principal DEX de la red Sui, ofreciendo a los usuarios una plataforma para intercambiar tokens y proporcionar liquidez. Como componente clave de la infraestructura dentro del ecosistema Sui, Cetus desempeñó un papel fundamental a la hora de facilitar el comercio descentralizado y contribuir a la liquidez general de la red. Su prominencia lo convirtió en un objetivo atractivo para los actores malintencionados que buscan explotar las vulnerabilidades en su base de código. Se desarrolla el hackeo de Cetus La violación se produjo el 22 de mayo de 2025, cuando los atacantes identificaron y explotaron una falla crítica en la lógica de los contratos inteligentes de Cetus. Concretamente, la vulnerabilidad se debía a un sutil error de desbordamiento aritmético que permitía al pirata informático manipular los mecanismos de contabilidad internos del protocolo. Al utilizar fichas falsas y manipular las curvas de precios de los fondos de liquidez, el atacante pudo drenar enormes cantidades de fondos sin activar sistemas de detección inmediata. Aproximadamente a las 3:52 a.m. PT (11:52 UTC), los monitores de la cadena de bloques comenzaron a detectar transacciones irregulares en varios fondos de liquidez de Cetus. En cuestión de horas, quedó claro el alcance de los daños: se habían desviado activos del protocolo por valor de más de 260 millones de dólares. Los fondos robados se intercambiaron rápidamente y se transfirieron a otras cadenas de bloques, lo que complicó los esfuerzos de recuperación. Impacto en el mercado y en el ecosistema Sui Las secuelas del hackeo fueron rápidas y graves. Las operaciones en Cetus se interrumpieron de inmediato, ya que los desarrolladores se apresuraron a evaluar la situación y mitigar las pérdidas adicionales. Mientras tanto, el valor de los tokens nativos asociados a la plataforma se desplomó, y algunos experimentaron caídas de hasta el 80% en cuestión de horas. Los inversores y los usuarios se enfrentaron a pérdidas masivas y la confianza en el ecosistema Sui se vio afectada. Un hecho particularmente alarmante se produjo cuando la red Sui intentó adoptar una controvertida contramedida: votar a favor de congelar la cartera del atacante que contenía 160 millones de dólares de los fondos robados. Si bien esta medida demostró un enfoque proactivo para la recuperación de activos, también generó debates sobre los principios de descentralización y sobre si tales acciones socavaban la confianza en la inmutabilidad de las transacciones basadas en la cadena de bloques. En un momento dado, el USD SUI perdió un 5% y el USD CETUS perdió un +- 40%, lo que supuso un salto increíble y aterrador a la vez. Detalles técnicos del exploit del protocolo Cetus Según el análisis proporcionado por la empresa de ciberseguridad Halborn, la causa principal del exploit radica en la forma en que Cetus validaba ciertas operaciones aritméticas durante el intercambio de tokens. Un descuido en la gestión de grandes cantidades provocó una situación de desbordamiento, que el atacante manipuló hábilmente para crear desequilibrios artificiales en los fondos de liquidez. Luego, estos desequilibrios se aprovecharon para extraer activos reales del sistema sin compensar adecuadamente a los proveedores de liquidez. Este tipo de vulnerabilidad es particularmente insidiosa porque no siempre se manifiesta en condiciones operativas normales; por el contrario, para activarla se requieren casos extremos específicos relacionados con valores muy elevados o secuencias de transacciones inusuales. Estos errores son notoriamente difíciles de detectar durante las auditorías y las fases de prueba estándar, lo que los convierte en los principales candidatos para que los exploten adversarios con muchos recursos. Esfuerzos de respuesta y recuperación de la Fundación Cetus y Sui (también conocida como Mysten Labs) Durante el ataque, según se informa, se congelaron alrededor de 160 millones de dólares que se devolverán a las piscinas de Cetus. Es por eso que toda la fundación Sui inició una votación para descongelar estos tokens. Tras el ataque, el equipo de Cetus emitió declaraciones públicas en las que reconocía la violación y describía los pasos a seguir para solucionarlo. Trabajaron en estrecha colaboración con empresas de análisis de cadenas de bloques como Elliptic y Chainalysis para rastrear el movimiento de los fondos robados e identificar posibles vías de recuperación. Además, surgieron debates sobre la implementación de actualizaciones de emergencia para corregir las vulnerabilidades existentes y mejorar la resiliencia futura contra ataques similares. Los miembros de la comunidad expresaron reacciones encontradas ante estos desarrollos. Si bien muchos elogiaron la transparencia demostrada por el liderazgo de Cetus tras el hackeo, otros criticaron la falta de preparación para estos escenarios y cuestionaron si se habían implementado suficientes salvaguardias antes del lanzamiento.
- Sui
- Security Protocols
1 - P&R expertosderiss159May 28, 2025
¿Se completará mi transacción si se acerca el límite?
He recibido una notificación que dice: «Se acerca el límite global de transacciones». Si inicio una transacción ahora, ¿se seguirá procesando en 24 horas?
- Move
03 - Discusióncod31May 27, 2025
Problemas para cambiar la billetera Sui en Cetus y Turbo Finance
Estoy intentando cambiar mi billetera Sui usando Cetus y Turbo Finance, pero no funciona. Tengo alrededor de 0,002 SUI como gasolina. ¿Qué medidas debo tomar para resolver este problema?
- Transaction Processing
03 - DiscusiónMay 26, 2025
¿Por qué SUI Wallet no tiene una función de revocación de DApp?
He estado usando SUI Wallet y me he dado cuenta de que no hay ninguna sección para revocar las DApps, lo que me parece inusual, ya que he oído que algunas interacciones no requieren la revocación. ¿Alguien puede explicar por qué es así y cómo funciona? Además, he establecido una estrategia de promedio de costos en dólares (DCA) y tengo curiosidad por saber cómo revocarla si siempre se ejecuta en segundo plano sin mi permiso.
- Sui
04
Sui is a Layer 1 protocol blockchain designed as the first internet-scale programmable blockchain platform.
- Sui
- Architecture
- SDKs and Developer Tools
- Move
- Security Protocols
- NFT Ecosystem
- Transaction Processing
- 👀 SEAL: creo que la privacidad de los datos de Web3 está a punto de cambiar8
- Administración de niños entre módulos con public_receive5
- AMM Bot en el ecosistema Sui52
- En resumen, el vídeo puede potenciar tu viaje como desarrollador de Sui5
- How to access and manage nested structs and dynamic fields in Move?56