El upgrade_cap en los paquetes Sui es un objeto especial que controla la autoridad para actualizar un paquete Move publicado. Cuando publicas un paquete en Sui, el sistema crea un objeto upgrade_cap vinculado a ese paquete. Este objeto lo conserva el editor o la autoridad designada y es necesario para realizar cualquier actualización o modificación futura en el código del paquete. Sin el upgrade_cap, el paquete se vuelve inmutable, lo que significa que no puede cambiar ni reemplazar sus módulos. Este diseño impone actualizaciones seguras y controladas y evita los cambios no autorizados, lo cual es crucial para mantener la confianza y la estabilidad en los contratos inteligentes implementados.

Desde el punto de vista de la CLI, cuando publicas un paquete mediante sui client publish, recibes el ID del paquete y el ID del objeto upgrade_cap. Para realizar la actualización, debes firmar una transacción que haga referencia al upgrade_cap actual y, a continuación, el sistema emitirá una nueva versión del paquete junto con un nuevo objeto upgrade_cap. En el código Move, no manipulas directamente el upgrade_cap, pero los scripts de implementación o la lógica fuera de la cadena deben gestionarlo de forma segura.

Desde el punto de vista arquitectónico, el upgrade_cap incorpora el control de la propiedad y los permisos para la gestión del ciclo de vida de los paquetes, lo que diferencia el modelo de paquetes de Sui de los contratos o proxies inmutables de Ethereum. La mejor práctica es almacenar el upgrade_cap de forma segura sin conexión o en un monedero multisig para evitar riesgos. Además, es necesario administrar y probar las versiones con cuidado antes de actualizar, ya que esto afecta a todos los usuarios según el paquete.

Entre los errores más comunes se incluyen perder el código upgrade_cap, que impide el acceso a las actualizaciones, o administrar mal la autoridad, lo que conlleva riesgos de seguridad. Con la CLI de Sui, puede consultar el upgrade_cap actual de un paquete o enviar transacciones de actualización para consumirlo y volver a emitirlo.

En resumen, el upgrade_cap es la clave criptográfica para la evolución de los paquetes en Sui, ya que permite realizar actualizaciones controladas y autorizadas, a la vez que se mantiene la descentralización y la seguridad. Administrarlo correctamente es esencial para que los flujos de trabajo de desarrollo e implementación de contratos inteligentes de Sui estén listos para la producción.

En Sui, upgrade_capse utiliza para gestionar la capacidad de actualización de los contratos inteligentes, lo que permite a los desarrolladores actualizar los contratos sin perder datos. Otorga permiso para realizar actualizaciones de contratos y, por lo general, es propiedad de una dirección confiable.

Puntos clave:

*Actualización de control: upgrade_capgarantiza que solo las direcciones autorizadas puedan activar las actualizaciones. *Código de movimiento: se utiliza en los módulos de movimiento para gestionar las actualizaciones. *Ejemplo de CLI:

 sui client publish --upgrade --package <package-id> --capability <upgrade-cap-id>

Mejores prácticas:

• Pruebe las actualizaciones en localnet/testnet.
• Asegúrelas upgrade_cappara evitar el acceso no autorizado.

El papel de upgrade_capen la red Sui

Propósito: controla quién puede actualizar un contrato o módulo inteligente.

*Qué hace: otorga permisos de actualización a direcciones específicas (normalmente administradores). Garantiza que solo las entidades autorizadas puedan modificar los contratos implementados.

Conceptos clave:

*Move Language: upgrade_capse implementa en Move para una gestión segura de los contratos. *Implementación: se especifica durante la implementación por contrato para permitir futuras actualizaciones únicamente en direcciones autorizadas.

Ejemplo de CLI:

sui client publish --gas-budget 10000 --upgrade-cap <upgrade-cap-id>

Ejemplo de código de movimiento:

public fun grant_upgrade_cap() {
    let upgrade_cap = UpgradeCap::new();
    // Assign cap to authorized address
}

Problemas comunes:

*Errores de permisos: una dirección no autorizada intenta actualizar. upgrade_cap*Capacidades faltantes: asegúrese de que esté configurada correctamente durante la implementación.

Mejores prácticas:

*Restringir upgrade_cap: limita el acceso a direcciones de confianza. *Realice una prueba en Localnet/Testnet: asegúrese de que el comportamiento es correcto antes de realizar la implementación en la red principal.

El** upgrade_cap**de Sui sirve como mecanismo de autorización para las actualizaciones de paquetes y funciona como un objeto de capacidad único que otorga derechos de actualización a su titular. A diferencia de las cadenas de EVM, en las que los contratos son inmutables, el sistema de actualización de Sui requiere este objeto para modificar los paquetes publicados, lo que proporciona una mutabilidad controlada y, al mismo tiempo, mantiene la seguridad. upgrade_capEl titular del sui client upgradepuede autorizar las actualizaciones mediante el package::authorize_upgradecomando de la CLI o mediante programación mediante la función de Move. Las mejores prácticas consisten en almacenarlos de forma segura upgrade_cap(a menudo en un Versioned``AdminCapcontenedor o en un envoltorio) e implementar los controles de propiedad adecuados, ya que perderlo bloquea permanentemente la capacidad de actualización y expone el riesgo de modificaciones no autorizadas.

En la red Sui, upgrade_capdesempeña un papel fundamental a la hora de permitir actualizaciones seguras y controladas de los paquetes Move después de su implementación inicial. Cuando publicas un paquete en Sui, UpgradeCapse crea un objeto de tipo y se devuelve. Este objeto es laúnica autoridadque permite futuras actualizaciones del paquete y, de hecho, actúa como una clave que otorga permiso para cambiar su código.

Debe conservar la propiedad de este paquete upgrade_capsi tiene la intención de actualizar su paquete más adelante. Si lo transfieres a otra dirección o lo grabas (por ejemplo, enviándolo a0x0), no es posible realizar más actualizaciones. Este diseño impone la inmutabilidad a menos que el creador del paquete lo apruebe explícitamente.

Por qué es importante UpgradeCap

El modelo centrado en objetos de Sui introduce este concepto para distinguir entre paquetes inmutables y paquetes actualizables. upgrade_capLos paquetes sin acceso a ellos se consideran permanentemente inmutables. Esto contrasta con las cadenas de EVM, en las que los contratos solo son mutables si los delegatecallproxies o los patrones actualizables se crean manualmente.

Ejemplo de flujo de trabajo de actualización

Al publicar un paquete:

sui client publish --path . --gas-budget 100000000

La salida incluye:

• ID del paquete
• ID de objeto UpgradeCap

Para realizar la actualización más adelante:

sui client upgrade \
  --package <original_package_id> \
  --module-upgrade-path <new_module_path> \
  --upgrade-cap <upgrade_cap_id> \
  --gas-budget 100000000

Uso de UpgradeCap en Move

En sus módulos Move, puede proteger las actualizaciones o las transiciones delicadas mediante el objeto de capacidad:

public entry fun secure_upgrade(upgrade_cap: &UpgradeCap, ctx: &mut TxContext) {
    // logic that uses upgrade_cap as proof of authority
}

O destrúyelo si quieres finalizar el paquete:

transfer::public_transfer(upgrade_cap, @0x0);

Esto revoca permanentemente tu capacidad de actualizar el paquete.

Mejores prácticas

*Almacénelas en un upgrade_capmonedero seguro o en un módulo de gobernaciónsi planea realizar actualizaciones en el futuro. *Quema upgrade_capelsi quieres que tu paquete sea inmutable, algo habitual en los contratos financieros o los NFT para fomentar la confianza de los usuarios. *Incluya la lógica de actualización en la gobernación, de modo que una DAO o una empresa multifirma apruebe las actualizaciones en lugar de una única clave privada. *Evite filtrar la upgrade_capidentificación, ya que la posesión equivale a la autoridad en Sui.

Errores comunes

*Falta upgrade_capdurante la actualización→ Da como resultado el error de «permiso denegado». *Transferencia accidental a valores nulo→ El paquete queda bloqueado para siempre. *Intentando solicitar la actualización en paquetes inmutables→ El sistema rechazará la transacción.

Más información

• Documentos: https://docs.sui.io/concepts/packages
• Ejemplos de actualización: https://docs.sui.io/build/upgrade
• Referencia de la CLI: https://docs.sui.io/reference/cli/client

En última instancia, upgrade_caprepresenta el compromiso de Sui con la autoridad explícita y el control minucioso sobre la evolución del estado y el código. Comprender cómo usarlos, almacenarlos y revocarlos es clave para crear contratos inteligentes seguros y fáciles de mantener en el ecosistema de Sui.

Función de los upgrade_cappaquetes en Sui

upgrade_capSe trata de unobjeto de capacidadque controla los permisos de actualización de los paquetes en el sistema de actualización centrado en objetos de Sui. A diferencia de las cadenas de EVM que utilizan patrones de proxy, Sui gestiona las actualizaciones a nivel de paquete a través de este objeto de capacidad dedicado.

Mecánica básica

Al publicar un paquete:

sui client publish --gas-budget 100000000 --path ./move_package

La transacción devuelve:

1. ID del paquete (identificador inmutable)
2. upgrade_capobjeto (0x2: :package: :UpgradeCap)

Este objeto de capacidad:

• Es unobjeto Sui de primera claseque se puede poseer, transferir o compartir
• Debe incluirse como entrada en cualquier transacción de actualización
• Contiene el identificador del paquete para el que autoriza las actualizaciones

Detalles técnicos clave

1.Modelo de seguridad:

• Solo el propietario del upgrade_cappuede actualizar el paquete
• Sigue el modelo de propiedad de objetos de Sui (sin autorización basada en el firmante)
• Se puede administrar en contratos o bloqueos de tiempo de varias firmas

2.Proceso de actualización:

  sui client upgrade --package [PACKAGE_ID] \
                    --upgrade-cap [UPGRADE_CAP_ID] \
                    --gas-budget 200000000 \
                    --path ./updated_package

3.Patrones de movimientos críticos:

  // Storing upgrade_cap in a publisher struct
  struct Publisher has key {
      id: UID,
      upgrade_cap: package::UpgradeCap,
  }
  
  // Upgrading (must use &mut reference)
  public entry fun upgrade(
      publisher: &mut Publisher,
      new_package: vector<u8>,
      new_modules: vector<vector<u8>>,
      ctx: &mut TxContext
  ) {
      package::upgrade_package(
          &mut publisher.upgrade_cap,
          new_package,
          new_modules,
          ctx
      )
  }

Ventajas específicas de Sui frente a EVM

-No se necesitan patrones de proxy: las actualizaciones se realizan a nivel de paquete, no a nivel de contrato -Compatibilidad con versiones atras: los objetos existentes siguen siendo válidos después de las actualizaciones -Seguridad basada en capacidades: utiliza el modelo de propiedad de objetos de Sui en lugar de los roles de administrador -Gobernanza transparente: Se upgrade_cappueden colocar en tesorerías de múltiples firmas o de la DAO

Errores y soluciones comunes

Mejores prácticas

1. Para producción: transfiera upgrade_capa una billetera multisig
2. Para contratos inmutables: quema la capacidad después de la publicación
3. Valide siempre la propiedad de la capacidad: object::is_owner(&cap, tx_context::sender(ctx))
4. Emite eventos sobre las actualizaciones: event::emit(UpgradeEvent { package_id, version })

Esto upgrade_capencarna el modelo de seguridad orientado a objetos de Sui: los permisos de actualización se tratan como activos transferibles y no como funciones administrativas codificadas, lo que proporciona opciones de gobierno flexibles y, al mismo tiempo, mantiene la seguridad.

El upgrade_cap en Sui es un objeto especial que representa la autoridad para actualizar un paquete Move publicado. Cuando publicas un paquete mediante la CLI de Sui, el sistema crea automáticamente un objeto upgrade_cap asociado a ese paquete. Este objeto controla la capacidad de actualizar o modificar el paquete después de su implementación inicial. Si no se mantiene pulsado el upgrade_cap, nadie puede actualizar el paquete y hacerlo inmutable.

Por ejemplo, al publicar un paquete:

sui client publish --gas-budget 10000 --path. /mi_paquete

El resultado incluye el ID del objeto upgrade_cap. Este objeto debe incluirse en las transacciones de actualización para demostrar la autoridad. Para actualizar el paquete, llame a:

<upgrade_cap_object_id>sui client upgrade --package <new_package_path>--upgrade-cap --gas-budget 10000

Esta transacción consume el antiguo upgrade_cap y emite uno nuevo para el paquete actualizado. El upgrade_cap impone un estricto control de permisos durante el ciclo de vida del paquete, lo que garantiza que solo las partes autorizadas puedan modificar el código del contrato.

Desde la perspectiva de Move, el código del paquete en sí mismo no manipula directamente el upgrade_cap porque se gestiona a nivel de protocolo. Sin embargo, los desarrolladores deben gestionar este objeto de forma segura fuera de la cadena y, por lo general, almacenarlo en carteras seguras o configuraciones multifirma para evitar actualizaciones no autorizadas.

Un upgrade_cap perdido significa que no puedes volver a actualizar el paquete, lo que bloquea el código para siempre. Esto enfatiza la importancia de las prácticas seguras de administración de claves. Además, la actualización de un paquete afecta a todos los usuarios que confían en él, por lo que las actualizaciones deben probarse minuciosamente en una red de prueba o una red local antes de su implementación.

Como los paquetes Sui están versionados, el upgrade_cap es la clave para pasar de una versión a otra. El sistema garantiza las actualizaciones atómicas al vincular el control de versiones de los paquetes a esta capacidad.

Puede consultar el upgrade_cap asociado a un paquete mediante la CLI o el SDK de Sui:

cliente sui: get-package <package_id>

que devuelve los detalles del paquete, incluido el upgrade_cap actual. Manejar el upgrade_cap de forma segura es parte de las mejores prácticas en los flujos de trabajo de desarrollo de Sui para evitar cambios de código accidentales o malintencionados.

A diferencia de los contratos inmutables de Ethereum o los patrones de actualización de proxy, el upgrade_cap de Sui es un objeto explícito con capacidad en cadena que controla las actualizaciones. Este diseño mejora la transparencia y la seguridad al convertir la autoridad de actualización en un objeto explícito en el sistema.

Los desarrolladores deben incorporar la administración de upgrade_cap en sus procesos de implementación y, por lo general, programar el proceso de actualización para incluir el objeto upgrade_cap y asegurarse de que esté firmado con las claves correctas.

Los upgrade_cappaquetes in Sui son un objeto especial que otorga a su propietario el derecho exclusivo de actualizar un paquete Move publicado. Cuando despliegas un paquete en la red Sui, Sui genera un UpgradeCapobjeto vinculado a tu cuenta. Esta capacidad actúa como una clave de acceso segura; sin ella, nadie (incluido usted) puede actualizar el código de ese paquete en el futuro.

La usas upgrade_capcuando llamas a la upgradefunción proporcionada por el módulo de sistema de Sui. La CLI le permite realizar actualizaciones como las siguientes:

sui client upgrade \
  --package-path /path/to/your/package \
  --upgrade-capability <upgrade_cap_object_id> \
  --gas-budget 100000000

Debe pasar el ID del UpgradeCapobjeto para autorizar la transacción de actualización. Si lo pierdes UpgradeCapo lo transfieres a una dirección inaccesible (por ejemplo0x0), el paquete pasa a ser inmutable porque nadie puede iniciar la actualización.

Si quieres deshabilitar deliberadamente las actualizaciones futuras, puedes incluir una función en tu paquete, como:

public entry fun burn_cap(cap: UpgradeCap) {
    sui::package::delete_upgrade_cap(cap);
}

Al llamar a esta función, se elimina la capacidad y se bloquea el código para siempre. Esto se recomienda para los paquetes que deben ser confiables o estar gobernados externamente.

Práctica recomendada: proteja siempre los suyos UpgradeCapy considere la posibilidad de transferirlos a una DAO o multisig si está trabajando en una infraestructura colaborativa o pública.

upgrade_cap###Función de los paquetes en Sui upgrade_capSe trata de unobjeto de capacidadque otorga permiso para actualizar un paquete Move en Sui. Es una función exclusiva de Sui que habilita lamutabilidad controladapara los paquetes publicados, a diferencia de los contratos inmutables en las cadenas de EVM.

###Conceptos clave 1.Qué hace: Publisher- Sostiene la UpgradePolicyy immutable(p. ej., compatible``arbitrary,).

• Necesario para autorizar las actualizaciones de los paquetes (p. ej., correcciones de errores o nuevas funciones).

2.Por qué Sui es único: upgrade_cap- Los contratos de EVM soninmutablestras el despliegue; Sui permite realizar actualizacionescon gobernación(vía).

• Las actualizaciones soneficientes en términos de gasolina(solo se vuelven a publicar los módulos modificados).

3.Implicaciones de seguridad:

• Quien la posea upgrade_cappuede cambiar la lógica del paquete.
• Práctica recomendada:Transfiérelo a un DAOo multisig después de la implementación.

###Mueva la estructura del código ####1. upgrade_capDefinir initen

module my_pkg::my_module {
  use sui::package;
  use sui::transfer;

  // Called once during package publish
  fun init(otw: &mut TxContext) {
    let (upgrade_cap, publisher) = package::claim(otw);
    transfer::transfer(upgrade_cap, tx_context::sender(otw)); // Give cap to deployer
  }
}

2. Actualización de un paquete*

module my_pkg::upgrader {
  use sui::package;

  // Requires the UpgradeCap
  public entry fun upgrade(
    upgrade_cap: &mut UpgradeCap,
    new_package: vector<u8>,
    otw: &mut TxContext
  ) {
    package::upgrade(upgrade_cap, new_package, otw);
  }
}

upgrade_capin Sui es unobjeto claveque controla las actualizaciones de los paquetes.

###Puntos clave: 1.Derechos de administración: solo el upgrade_captitular puede actualizar el paquete. 2.Seguridad: evita los cambios no autorizados (a diferencia de los contratos inmutables de Ethereum). 3. sui client upgradeUso de la CLI: obligatorio para.

###Ejemplo de movimiento:

struct UpgradeCap has key, store { id: UID }  

###Mejores prácticas: ✔ Almacene de forma segura (p. ej., multisig). ✔ Pruebe localnetprimero las actualizaciones.

Por qué Unique: Sui permite actualizaciones (frente a la inmutabilidad de EVM).

• (Perder upgrade_cap= ¡no más mejoras!) *

1. Concepto fundamental**

upgrade_capEs unobjeto privilegiadoque controla las actualizaciones de los paquetes en Sui. A diferencia de las cadenas de EVM, donde los contratos son inmutables, Sui permite una mutabilidad controlada a través de este sistema basado en capacidades.

###2. Propiedades clave

2. Trasladar la implementación**

####Estructura basica

module my_pkg::admin {
    use sui::package;
    use sui::transfer;
    use sui::tx_context;

    // Generated during initial publish
    struct UpgradeCap has key, store { 
        id: UID 
    }

    // Initialize and transfer cap
    public fun init(ctx: &mut tx_context::TxContext) {
        let (upgrade_cap, publisher) = package::claim_upgrade_cap(ctx);
        transfer::transfer(upgrade_cap, tx_context::sender(ctx));
    }
}

####Flujo de actualización

module my_pkg::upgrader {
    use sui::package;
    use sui::upgrade_cap;

    public entry fun upgrade(
        cap: &mut upgrade_cap::UpgradeCap,
        policy: u8,
        digest: vector<u8>,
        ctx: &mut tx_context::TxContext
    ) {
        package::authorize_upgrade(cap, policy, digest);
        let new_pkg = package::make_upgrade_ticket(cap, policy, digest);
        // ... complete upgrade
    }
}

3. Flujo de trabajo de CLI**

####Publicación inicial

sui client publish --gas-budget 1000000000
# Output includes UpgradeCap object ID

####Autorizar la actualización

sui client call \
  --package <UPGRADE_CAP_PKG> \
  --module admin \
  --function authorize_upgrade \
  --args <UPGRADE_CAP_ID> 1 0x<COMPILED_PACKAGE_DIGEST> \
  --gas-budget 1000000000

####Ejecutar la actualización

sui client upgrade --upgrade-capability <UPGRADE_CAP_ID> \
  --gas-budget 1000000000

###4. Patrones de seguridad** ####Capacidad de anidad

struct AdminCap has key {
    id: UID,
    upgrade_cap: UpgradeCap  // Delegatable
}

####Actualizaciones con tiempo bloqueado

module my_pkg::timelock {
    struct TimedUpgradeCap has key {
        cap: UpgradeCap,
        unlock_epoch: u64
    }

    public fun upgrade_when_ready(
        cap: &mut TimedUpgradeCap,
        ctx: &mut TxContext
    ) {
        assert!(tx_context::epoch(ctx) >= cap.unlock_epoch, ELOCKED);
        package::authorize_upgrade(&mut cap.cap, ...);
    }
}

###5. Dificultades comunes**

###6. Políticas de actualización**

// Bitflags determining upgrade flexibility
const POLICY_COMPATIBLE: u8 = 0x1;  // Backwards-compatible
const POLICY_ADDITIVE: u8  = 0x2;   // New functions only
const POLICY_BREAKING: u8 = 0x4;    // Full changes

###7. Estrategia de pruebas** ####Localnet Dry-Run

sui client publish --upgrade-policy 7 --dry-run

####Simulación de actualización

#[test_only]
module test {
    fun test_upgrade() {
        let (cap, _) = package::test_upgrade_cap();
        package::authorize_upgrade(&mut cap, ...);
        assert!(package::test_is_authorized(cap), 0);
    }
}

###Impacto arquitectónico 1.Gobernanza descentralizada:

• Las DAO pueden mantener los límites de actualización shared- Esquemas de múltiples firmas mediante objetos

2.Preparación empresarial:

• Implementaciones escalonadas con indicadores de políticas
• Capacidades de revocación de emergencia

3.Ventajas de DevEx:

• Corregir errores después de la implementación
• Migraciones de almacenamiento que ahorran gas

Para sistemas de producción:

• Almacenar UpgradeCapen cámara frigorífica
• Implementar mecanismos de votación mejorados
• Supervise mediante la pestaña de actualización de Sui Explorer

En Sui, upgrade_capes un objeto especial que le da derecho a actualizar un paquete Move publicado. Cuando despliegas un paquete con--upgradeable, automáticamente obtienes un UpgradeCapobjeto vinculado a él. Este objeto actúa como un permiso: sin él, no puedes enviar actualizaciones a ese paquete. Debes conservar este objeto y firmarlo siempre que quieras actualizar el código, lo que lo convierte en un poderoso mecanismo de control de acceso para el desarrollo en cadena.

Este diseño diferencia a Sui de las cadenas de EVM, en las que la lógica de actualización suele gestionarse mediante contratos de proxy y funciones de administración independientes. En Sui, el permiso de actualización está integrado en el sistema de objetos. Si estás creando una colección de NFT, un contrato de DeFi o cualquier sistema que necesite actualizaciones futuras, esto UpgradeCapgarantiza que solo el desarrollador de confianza (o de varias firmas) con ese límite pueda impulsar esos cambios, lo que reduce la posibilidad de actualizaciones no autorizadas.

Para crear un paquete actualizable, usa la CLI de Sui:

sui client publish --path . --gas-budget 100000000 --with-unpublished-dependencies --upgradeable

Una vez publicado, verás un mensaje upgrade_capen el resultado como este:

"createdObjects": [
  {
    "objectType": "0x2::package::UpgradeCap",
    "objectId": "0xabc123...",
    ...
  }
]

Para actualizar el paquete más adelante, compílelo en un .jsonresumen y ejecute:

sui client upgrade --package-id <PACKAGE_ID> --module <PATH_TO_COMPILED_MODULE> --upgrade-capability <CAP_OBJECT_ID> --gas-budget 100000000

Asegúrate de que el ID del objeto --upgrade-capabilitycoincide con el que obtuviste en la primera publicación. Si pierdes este objeto o te olvidas de protegerlo (por ejemplo, transfiriéndolo a un monedero multisig), cualquier persona que lo reciba podrá modificar tu contrato.

Los errores más comunes incluyen olvidarse de almacenarloupgrade_cap, usar un resumen no válido o intentar actualizar un paquete que no se puede actualizar. La mejor práctica es guardarlos de upgrade_capforma segura, especialmente en producción, y supervisarlos de cerca durante las auditorías.

Puedes obtener más información sobre upgrade_caplas actualizaciones seguras de los paquetes en los documentos oficiales de Sui: https://docs.sui.io/build/package-upgrades