Zum Hauptinhalt springen

CosmWasm-Entwicklung

QoreChain unterstützt CosmWasm-Smart-Contracts und ermöglicht es Entwicklern, sichere, sandboxed Programme in Rust zu schreiben, die zu WebAssembly kompiliert werden. CosmWasm-Contracts laufen innerhalb der Triple-VM-Architektur von QoreChain parallel zu EVM- und SVM-Programmen.

hinweis

Die folgenden Befehle verwenden das qorechain-vladi-Mainnet, live seit dem 7. Juni 2026, auf dem die Chain-Version v3.1.97 läuft. Ersetzen Sie --chain-id qorechain-diana für das Testnet.

Code-Upload und Instanziierung erfordern derzeit eine explizite Berechtigung

Zum Zeitpunkt der Erstellung dieses Dokuments sind code_upload_access und instantiate_default_permission sowohl im Mainnet als auch im Testnet auf Nobody gesetzt — das bedeutet, MsgStoreCode und MsgInstantiateContract stehen standardmäßig nicht beliebigen Accounts offen, im Einklang mit einer branchenweiten CosmWasm-Sicherheitswarnung. Sie benötigen eine Governance-Entscheidung, um Ihrem Account (oder einer bestimmten Adressliste) die Upload-/Instanziierungsberechtigung zu erteilen, bevor die untenstehenden Schritte gelingen — prüfen Sie zunächst die aktuellen Live-Parameter, da genau diese Einstellung durch Governance geändert werden kann:

qorechaind query wasm params
# or: curl -s https://api.qore.host/cosmwasm/wasm/v1/codes/params  (substitute api-testnet.qore.host for testnet)

Diese Einschränkung betrifft bereits instanziierte Contracts nicht — execute und query gegen einen bestehenden Contract funktionieren unabhängig von dieser Einstellung normal.

Voraussetzungen​

AbhängigkeitVersionZweck
RustAktuell stabilContract-Kompilierung
wasm32-unknown-unknownTargetWebAssembly-Kompilierungsziel
cargo-generateAktuellProjekt-Scaffolding
cosmwasm-std1.5+CosmWasm-Standardbibliothek

Installieren Sie das Wasm-Target:

rustup target add wasm32-unknown-unknown

Contract-Lebenszyklus​

CosmWasm-Contracts folgen einem fünfstufigen Lebenszyklus: Build, Store, Instantiate, Execute und Query.

  1. Build — Kompilieren Sie Ihren Contract zu optimiertem WebAssembly:

    cd my-contract

    # Standard build
    cargo build --release --target wasm32-unknown-unknown

    # Optimized build (recommended for deployment)
    docker run --rm -v "$(pwd)":/code \
      cosmwasm/rust-optimizer:0.15.0

    Die optimierte .wasm-Datei befindet sich im Verzeichnis artifacts/.

  2. Store — Laden Sie den kompilierten Contract in die Chain hoch:

    qorechaind tx wasm store contract.wasm \
      --from mykey \
      --gas auto \
      --gas-adjustment 1.3 \
      -y

    Nachdem die Transaktion bestätigt wurde, fragen Sie die gespeicherte Code-ID ab:

    qorechaind query wasm list-code

  3. Instantiate — Erstellen Sie eine neue Contract-Instanz aus einer gespeicherten Code-ID:

    qorechaind tx wasm instantiate <code-id> \
      '{"count": 0, "owner": "qor1..."}' \
      --label "my-counter-contract" \
      --from mykey \
      --no-admin \
      --gas auto \
      --gas-adjustment 1.3 \
      -y
    FlagBeschreibung
    <code-id>Numerische ID, die von der Store-Transaktion zurückgegeben wird
    --labelLesbares Label für diese Instanz
    --no-adminKeine Admin-Adresse (Contract ist unveränderlich)
    --admin <address>Legt einen Admin fest, der den Contract migrieren kann

    Rufen Sie die Contract-Adresse ab:

    qorechaind query wasm list-contracts-by-code <code-id>

  4. Execute — Rufen Sie den Execute-Einstiegspunkt eines Contracts auf, um den Zustand zu ändern:

    qorechaind tx wasm execute <contract-addr> \
      '{"increment": {}}' \
      --from mykey \
      --gas auto \
      -y

    Execute mit angehängten Mitteln:

    qorechaind tx wasm execute <contract-addr> \
      '{"deposit": {}}' \
      --amount 1000000uqor \
      --from mykey \
      -y

  5. Query — Lesen Sie den Contract-Zustand aus, ohne eine Transaktion einzureichen:

    qorechaind query wasm contract-state smart <contract-addr> \
      '{"get_count": {}}'

    Query-Antworten werden als JSON zurückgegeben.

Nützliche Abfragen​

# List all stored code
qorechaind query wasm list-code

# List all instances of a specific code ID
qorechaind query wasm list-contracts-by-code <code-id>

# Get contract info (code ID, admin, label)
qorechaind query wasm contract <contract-addr>

# Get raw contract state by key
qorechaind query wasm contract-state raw <contract-addr> <key-hex>

# Get full contract state (all keys)
qorechaind query wasm contract-state all <contract-addr>

# Get contract history (instantiate/migrate events)
qorechaind query wasm contract-history <contract-addr>

Contract-Struktur​

Ein typischer CosmWasm-Contract hat drei Einstiegspunkte:

use cosmwasm_std::{
    entry_point, Binary, Deps, DepsMut, Env, MessageInfo,
    Response, StdResult,
};

#[entry_point]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    // Initialize contract state
    Ok(Response::new().add_attribute("method", "instantiate"))
}

#[entry_point]
pub fn execute(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: ExecuteMsg,
) -> StdResult<Response> {
    // Handle state-changing operations
    Ok(Response::new().add_attribute("method", "execute"))
}

#[entry_point]
pub fn query(
    deps: Deps,
    _env: Env,
    msg: QueryMsg,
) -> StdResult<Binary> {
    // Handle read-only queries
    Ok(Binary::default())
}

Cross-VM-Aufrufe​

CosmWasm-Contracts können über das x/crossvm-Modul mit Contracts interagieren, die auf der EVM und SVM bereitgestellt wurden. Cross-VM-Aufrufe von CosmWasm verwenden den asynchronen Nachrichtenpfad:

use cosmwasm_std::{CosmosMsg, CustomMsg};

// Call an EVM contract from CosmWasm
let cross_vm_msg = CosmosMsg::Custom(QoreChainMsg::CrossVMCall {
    target_vm: "evm".to_string(),
    target_contract: "0x1234...abcd".to_string(),
    payload: hex::encode(abi_encoded_data),
    funds: vec![],
});

Ok(Response::new().add_message(cross_vm_msg))

Die Nachricht wird in eine Warteschlange eingereiht und vom EndBlocker im nächsten Block verarbeitet. Den vollständigen Nachrichten-Lebenszyklus finden Sie unter Cross-VM-Interoperabilität.

Modul-Integration​

CosmWasm-Contracts können über standardmäßige Nachrichtenübermittlung mit Cosmos-SDK-Modulen interagieren:

// Send native tokens via the bank module
let send_msg = BankMsg::Send {
    to_address: "qor1recipient...".to_string(),
    amount: vec![Coin {
        denom: "uqor".to_string(),
        amount: Uint128::new(1_000_000),
    }],
};

// Delegate to a validator via the staking module
let delegate_msg = StakingMsg::Delegate {
    validator: "qorvaloper1...".to_string(),
    amount: Coin {
        denom: "uqor".to_string(),
        amount: Uint128::new(1_000_000),
    },
};

Contract-Migration​

Wenn der Contract mit einer --admin-Adresse instanziiert wurde, kann der Admin ihn zu einer neuen Code-ID migrieren:

qorechaind tx wasm migrate <contract-addr> <new-code-id> \
  '{"migrate_msg": {}}' \
  --from admin-key \
  -y

Dies ruft den migrate-Einstiegspunkt des neuen Codes mit dem bestehenden Contract-Zustand auf.

Nächste Schritte​