Desplegar Smart Contracts (Go)

Esta guía muestra los pasos principales para desplegar un smart contract ULVM compilado usando el ULedger Go SDK.

Los pasos son:

1. Cargar una billetera (el firmante)
2. Leer el archivo .wat del contrato
3. Crear una UL_TransactionSession hacia un node
4. Enviar una transacción DEPLOY_SMART_CONTRACT

info

Antes de desplegar contratos en la mayoría de las redes, la billetera debe estar registrada on-chain (TX_CREATE_WALLET).
Si el despliegue falla con errores de autorización, se debe registrar primero la billetera.

---

1. Requisitos previos

Se necesita:

• Un endpoint de node (los ejemplos usan https://your-node-url como marcador de posición, por lo que se debe reemplazar por la URL de la red que se use)
• Un blockchainId
• Una billetera con la que se pueda firmar
• Un archivo de contrato en formato .wat (texto de WebAssembly), por ejemplo contract.wat

---

2. Cargar una billetera (enfoque recomendado)

Recomendado: cargar desde un archivo .ukey creado por el flujo de billeteras del SDK.

w, err := wallet.LoadFromFile("./wallets/my_wallet.ukey", "")
if err != nil {
  return fmt.Errorf("load wallet: %w", err)
}

Se debe evitar codificar claves privadas directamente en los ejemplos. Se recomienda usar archivos .ukey o variables de entorno.

---

3. Leer el archivo del contrato

Se recomienda desplegar el contrato como un archivo .wat (texto de WebAssembly).

watBytes, err := os.ReadFile("./auction.wat")
if err != nil {
  return fmt.Errorf("read contract file: %w", err)
}
sourceCode := string(watBytes)

---

4. Elegir una dirección de contrato

Muchas cadenas tratan la dirección del contrato como un valor explícito (pasado como To).

Un valor predeterminado simple y seguro es una cadena hex aleatoria de 32 bytes:

func randomHex32() (string, error) {
  b := make([]byte, 32)
  if _, err := rand.Read(b); err != nil {
    return "", err
  }
  return hex.EncodeToString(b), nil
}

contractAddress, err := randomHex32()
if err != nil {
  return fmt.Errorf("generate contract address: %w", err)
}

---

5. Crear una sesión de transacción

session, err := transaction.NewUL_TransactionSession(nodeEndpoint, w)
if err != nil {
  return fmt.Errorf("create session: %w", err)
}

NewUL_TransactionSession normalmente realiza llamadas iniciales al node (como /health) y prepara la sesión para firmar y enviar transacciones.

---

6. Construir y enviar la transacción de despliegue

Esta es la "lógica principal":

input := transaction.ULTransactionInput{
  BlockchainId: blockchainId,
  From:         w.Address,                              // dirección de la billetera firmante
  To:           contractAddress,                        // donde vivirá el contrato
  Payload:      sourceCode,                             // texto WAT
  PayloadType:  transaction.DEPLOY_SMART_CONTRACT.String(),
}

tx, err := session.GenerateTransaction(input)
if err != nil {
  return fmt.Errorf("deploy contract: %w", err)
}

if tx.TransactionId == "" {
  return fmt.Errorf("deploy returned empty transaction id")
}

fmt.Println("Deploy TX:", tx.TransactionId)
fmt.Println("Status:", tx.Status)
fmt.Println("Output:", tx.Output)
fmt.Println("Contract address:", contractAddress)

Qué esperar como respuesta

• tx.TransactionId = identificador de la transacción
• tx.Status = SUBMITTED, ACCEPTED, o REJECTED
• tx.Output = SUCCESS o un motivo de rechazo

---

7. Siguiente paso: Invocar el contrato

Una vez desplegado, se puede llamar al contrato con una transacción INVOKE_SMART_CONTRACT.

Continuar en: Invocar Smart Contracts (Go).