Que es un smart contract?

Un smart contract (contrato inteligente) es un programa que vive en una blockchain y que ejecuta automáticamente acuerdos cuando se cumplen ciertas condiciones.

En palabras simples: Es como un contrato digital que se cumple solo, sin necesidad de intermediarios.

Por ejemplo:

Si alguin envía dinero → el contrato libera un producto o servicio
Si no se cumple una condición → el dinero se devuelve automáticamente

Todo queda registrado de forma segura, transparente y no se puede modificar fácilmente.

La red de Stellar usa un lenguaje de programación específico para el desarrollo de contratos inteligentes llamado Soroban.

Porque Soroban y no Solidity?

Soroban existe para llevar contratos inteligentes a la red de Stellar sin perder lo que hace especial a Stellar: transacciones rapidas, costos bajos y predecibles, enfoque en pagos globales y accesibilidad.

Solidity ha tenido muchos problemas historicos que han servido como casos de estudio durante el proceso de desarrollo de Soroban, Stellar quería un sistema más seguro desde la base.

Soroban permite agregar contratos inteligentes a Stellar manteniendo su enfoque en pagos rápidos y de bajo costo. A diferencia de Solidity, Stellar utiliza Rust para priorizar seguridad, eficiencia y mayor control, construyendo una infraestructura sólida desde la base pensada para aplicaciones financieras reales y escalables.

Open Zeppelin

OpenZepplin es importante porque ofrece contratos y herramientas preconstruidas, seguras y auditadas que ayudan a desarrollar smart contracts sin tener que empezar desde cero. En lugar de reinventar lógica crítica (como control de acceso, manejo de fondos o validaciones), puedes reutilizar estándares probados que reducen errores y vulnerabilidades. En simple: te permite construir más rápido, con mejores prácticas y con un nivel mucho mayor de seguridad, algo clave cuando estás manejando dinero en blockchain.

Tutorial: Smart Contract Kickstarter en Soroban

¿Qué vamos a construir?

Un contrato inteligente donde:

Un agricultor crea una campaña con meta de financiamiento
Usuarios pueden aportar fondos
Si se cumple la meta → agricultor retira fondos
Si no → usuarios pueden retirar su dinero

⚙️ Paso 1: Instalar Soroban CLI

Necesitas tener Rust instalado primero:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Luego instala Soroban CLI:

cargo install --locked soroban-cli

Verifica instalación:

soroban --version

📦 Paso 2: Crear un proyecto Soroban

soroban contract init kickstarter
cd kickstarter

Esto crea la estructura base:

/src
  lib.rs
Cargo.toml

✍️ Paso 3: Escribir el contrato (Kickstarter)

Edita src/lib.rs con el siguiente código auditado de OpenZeppelin:

#![no_std]
use soroban_sdk::{contract, contractimpl, Env, Symbol, Address, Map};

#[contract]
pub struct KickstarterContract;

#[derive(Clone)]
pub struct Campaign {
    owner: Address,
    goal: i128,
    pledged: i128,
    claimed: bool,
}

#[contractimpl]
impl KickstarterContract {

    // Crear campaña
    pub fn create_campaign(env: Env, owner: Address, goal: i128) {
        let key = Symbol::new(&env, "campaign");
        
        let campaign = Campaign {
            owner,
            goal,
            pledged: 0,
            claimed: false,
        };

        env.storage().set(&key, &campaign);
    }

    // Aportar fondos
    pub fn pledge(env: Env, from: Address, amount: i128) {
        let key = Symbol::new(&env, "campaign");
        let mut campaign: Campaign = env.storage().get(&key).unwrap();

        campaign.pledged += amount;

        env.storage().set(&key, &campaign);
    }

    // Retirar fondos (si meta cumplida)
    pub fn claim(env: Env, caller: Address) {
        let key = Symbol::new(&env, "campaign");
        let mut campaign: Campaign = env.storage().get(&key).unwrap();

        if campaign.pledged < campaign.goal {
            panic!("Meta no alcanzada");
        }

        if campaign.owner != caller {
            panic!("No autorizado");
        }

        if campaign.claimed {
            panic!("Ya retirado");
        }

        campaign.claimed = true;
        env.storage().set(&key, &campaign);
    }
}

🛡️ Nota estilo OpenZeppelin

Estos son los principios de OZ que estamos usando en nuestro contrato:

✅ Validaciones claras (panic!)
✅ Control de acceso (owner)
✅ Estado explícito (claimed)
✅ Lógica simple y auditable

🛠️ Paso 4: Compilar el contrato

soroban contract build

Esto genera:

target/wasm32-unknown-unknown/release/kickstarter.wasm

🌐 Paso 5: Crear cuenta en Testnet

Genera una nueva identidad con un nombre de ejemplo (alice)

soroban config identity generate alice

Obtén fondos (faucet):

soroban config identity fund alice --network testnet

🚀 Paso 6: Deploy del contrato

Primero configura la red a testnet:

soroban config network add testnet \
  --rpc-url https://soroban-testnet.stellar.org \
  --network-passphrase "Test SDF Network ; September 2015"

Luego deploya:

soroban contract deploy \
  --wasm target/wasm32-unknown-unknown/release/kickstarter.wasm \
  --source alice \
  --network testnet

👉 Recuerda guardar el Contract ID que te devuelve!

⚡ Paso 7: Invocar funciones

Crear campaña

soroban contract invoke \
  --id <CONTRACT_ID> \
  --source alice \
  --network testnet \
  -- create_campaign \
  --owner alice \
  --goal 1000

Aportar fondos

soroban contract invoke \
  --id <CONTRACT_ID> \
  --source alice \
  --network testnet \
  -- pledge \
  --from alice \
  --amount 500

Reclamar fondos

soroban contract invoke \
  --id <CONTRACT_ID> \
  --source alice \
  --network testnet \
  -- claim \
  --caller alice

🧪 Paso 8: Probar en Stellar Lab UI

Ve al Stellar Laboratory en lab.stellar.org
Conecta a Testnet
Usa tu Contract ID
Ejecuta funciones manualmente:
- create_campaign
- pledge
- claim

Esto te permite:

Ver inputs/output en UI
Simular usuarios
Debuggear fácilmente

🚀 Siguientes mejoras (nivel pro)

Para llevar esto a nivel producción:

🔐 Reembolsos (refund())
👥 Múltiples campañas (usar Map con IDs)
⏳ Deadline (timestamp)
💰 Integración con tokens (USDC en Stellar)
📊 Eventos (env.events())
🧪 Tests automatizados (cargo test)

En Resumen

Los pasos para crear, desplegar y probar tu contrato inteligente son estos:

Instalas Soroban CLI
Creas proyecto
Escribes contrato
Compilas a WASM
Creas cuenta testnet
Deploy
Invocas funciones
Testeas en UI

Esperamos que esta información te sea util en tu camino como builder y recuerda seguir construyendo ideas para convertirlas en productos.

Y si quieres, aqui estan los links para unirte a la comunidad oficial de builders de Stellar en Latam.

Hola Stellar: Intro a Soroban