Enterprise Smart Contracts with Privacy-First Architecture
With CosmWasm Comparison
Daml is a purpose-built smart contract language designed for multi-party business workflows. Canton is the distributed ledger protocol that executes Daml contracts with unique privacy guarantees.
Privacy-first, legally-enforceable contracts with sub-transaction privacy.
CosmWasm is a smart contract platform for the Cosmos ecosystem, using Rust to write WebAssembly-compiled contracts.
Composability, interoperability via IBC, and general-purpose smart contracts.
| Aspect | Canton/DAML | CosmWasm |
|---|---|---|
| Execution Model | UTXO-based (contracts as active agreements) | Account-based (contracts as deployed code) |
| Privacy | Sub-transaction privacy (only parties see relevant data) | All data public on-chain |
| Consensus | Domain-based (multiple sync domains) | BFT (Tendermint/CometBFT) |
| Language | Daml (functional, domain-specific) | Rust (general-purpose) |
| Interoperability | Cross-domain atomic transactions | IBC protocol |
┌─────────────────┐ ┌─────────────────┐
│ Domain A │ │ Domain B │
│ (Bank Ledger) │ │ (Exchange) │
│ │ │ │
│ Participant 1 ─┼─────┼─ Participant 1 │
│ Participant 2 │ │ Participant 3 │
└─────────────────┘ └─────────────────┘
Atomic transactions across domains
via Canton protocol
┌─────────────────┐ ┌─────────────────┐
│ Chain A │ │ Chain B │
│ (Osmosis) │ IBC │ (Juno) │
│ │◄───►│ │
│ Contract A │ │ Contract B │
│ CW20 Tokens │ │ NFT Market │
└─────────────────┘ └─────────────────┘
Cross-chain communication via
IBC packet relay
-- Daml: A simple asset transfer contract
template Asset
with
issuer : Party
owner : Party
description : Text
quantity : Decimal
where
signatory issuer, owner
choice Transfer : ContractId Asset
with
newOwner : Party
controller owner
do
create this with owner = newOwner
choice Split : (ContractId Asset, ContractId Asset)
with
splitQuantity : Decimal
controller owner
do
assert (splitQuantity > 0.0 && splitQuantity < quantity)
asset1 <- create this with quantity = splitQuantity
asset2 <- create this with quantity = quantity - splitQuantity
return (asset1, asset2)// CosmWasm: A simple asset transfer contract
use cosmwasm_std::{
entry_point, DepsMut, Env, MessageInfo,
Response, StdResult, Uint128, Addr,
};
use cw_storage_plus::Map;
pub const BALANCES: Map<&Addr, Uint128> = Map::new("balances");
#[entry_point]
pub fn execute(
deps: DepsMut,
_env: Env,
info: MessageInfo,
msg: ExecuteMsg,
) -> StdResult<Response> {
match msg {
ExecuteMsg::Transfer { recipient, amount } => {
let sender_balance = BALANCES
.load(deps.storage, &info.sender)?;
let new_balance = sender_balance.checked_sub(amount)?;
BALANCES.save(deps.storage, &info.sender, &new_balance)?;
let recipient_addr = deps.api.addr_validate(&recipient)?;
let recipient_balance = BALANCES
.may_load(deps.storage, &recipient_addr)?
.unwrap_or_default();
BALANCES.save(
deps.storage,
&recipient_addr,
&(recipient_balance + amount)
)?;
Ok(Response::new()
.add_attribute("action", "transfer"))
}
}
}-- Contracts have a lifecycle
-- 1. Created (active)
-- 2. Archived (consumed/exercised)
template IOU
with
issuer : Party
owner : Party
amount : Decimal
where
signatory issuer
observer owner
-- Exercising archives this contract
choice Settle : ()
controller issuer
do
-- Settlement logic
return ()
-- Non-consuming choice (contract stays active)
nonconsuming choice GetBalance : Decimal
controller owner
do
return amount// Contracts persist and mutate state
pub fn execute_deposit(
deps: DepsMut,
info: MessageInfo,
) -> StdResult<Response> {
let mut state = STATE.load(deps.storage)?;
// State is mutated in place
state.total_deposited += info.funds[0].amount;
state.deposits.push(Deposit {
depositor: info.sender.clone(),
amount: info.funds[0].amount,
});
STATE.save(deps.storage, &state)?;
Ok(Response::new())
}| Dimension | Canton/DAML | CosmWasm |
|---|---|---|
| Primary Strength | Privacy & Multi-party workflows | Composability & IBC |
| Contract Model | Agreements (UTXO) | Programs (Account) |
| Language | Daml (DSL) | Rust (GPL) |
| Authorization | Compile-time checked | Runtime checks |
| Privacy | Native sub-tx privacy | Public (by default) |
| Interop | Multi-domain atomic | IBC protocol |
| Learning Curve | Moderate (new DSL) | Steep (Rust + Cosmos) |
| Ecosystem | Enterprise focus | Public blockchain |
| Best For | B2B workflows | Public DeFi |
-- Define reusable interface
interface Transferable where
viewtype TransferableView
getOwner : Party
choice TransferTo : ContractId Transferable
with newOwner : Party
controller getOwner this
do
create this with owner = newOwner
-- Implement interface
template Stock
with
issuer : Party
owner : Party
ticker : Text
shares : Int
where
signatory issuer, owner
interface instance Transferable for Stock where
view = TransferableView with owner
getOwner = ownerexception InsufficientFunds
with
requested : Decimal
available : Decimal
where
message "Insufficient funds: requested " <> show requested
<> ", available " <> show available
template Account
with
bank : Party
owner : Party
balance : Decimal
where
signatory bank, owner
choice Withdraw : ContractId Account
with amount : Decimal
controller owner
do
when (amount > balance) do
throw InsufficientFunds with
requested = amount
available = balance
create this with balance = balance - amountmodule Test where
import Daml.Script
import Main
testTransfer : Script ()
testTransfer = script do
-- Setup parties
alice <- allocateParty "Alice"
bob <- allocateParty "Bob"
-- Create asset
assetId <- submit alice do
createCmd Asset with
issuer = alice
owner = alice
description = "Gold"
quantity = 100.0
-- Transfer
newAssetId <- submit alice do
exerciseCmd assetId Transfer with
newOwner = bob
-- Verify
Some asset <- queryContractId bob newAssetId
assert (asset.owner == bob)pub fn execute_swap(
deps: DepsMut,
env: Env,
info: MessageInfo,
offer_asset: Asset,
ask_asset: AssetInfo,
) -> Result<Response, ContractError> {
// Create sub-message to DEX
let swap_msg = WasmMsg::Execute {
contract_addr: DEX_CONTRACT.load(deps.storage)?.to_string(),
msg: to_json_binary(&DexExecuteMsg::Swap {
offer_asset: offer_asset.clone(),
ask_asset: ask_asset.clone(),
})?,
funds: vec![],
};
// Reply on success to handle result
let submsg = SubMsg::reply_on_success(swap_msg, SWAP_REPLY_ID);
Ok(Response::new()
.add_submessage(submsg)
.add_attribute("action", "swap"))
}
#[entry_point]
pub fn reply(
deps: DepsMut,
_env: Env,
msg: Reply
) -> Result<Response, ContractError> {
match msg.id {
SWAP_REPLY_ID => {
let response = parse_reply_result(msg)?;
// Process received tokens...
Ok(Response::new())
}
_ => Err(ContractError::UnknownReplyId { id: msg.id }),
}
}#[entry_point]
pub fn migrate(
deps: DepsMut,
_env: Env,
msg: MigrateMsg
) -> Result<Response, ContractError> {
let ver = cw2::get_contract_version(deps.storage)?;
if ver.version.parse::<u64>()? < 2 {
// Migrate from v1 to v2
let old_state: StateV1 = STATE_V1.load(deps.storage)?;
let new_state = StateV2 {
owner: old_state.owner,
total: old_state.total,
// New field with default
fee_rate: Decimal::percent(1),
};
STATE.save(deps.storage, &new_state)?;
}
cw2::set_contract_version(
deps.storage,
CONTRACT_NAME,
CONTRACT_VERSION
)?;
Ok(Response::new())
}#[entry_point]
pub fn ibc_packet_receive(
deps: DepsMut,
_env: Env,
msg: IbcPacketReceiveMsg,
) -> Result<IbcReceiveResponse, ContractError> {
let packet_data: PacketData = from_json(&msg.packet.data)?;
// Process cross-chain message
match packet_data {
PacketData::Transfer { recipient, amount } => {
// Mint tokens on this chain
mint_tokens(deps, recipient, amount)?;
}
}
Ok(IbcReceiveResponse::new()
.add_attribute("action", "receive"))
}daml new my-project
Create project
vim daml/Main.daml
Write contracts
daml build
Build DAR package
daml test
Run Daml Script tests
daml start
Start local sandbox
canton console
Deploy to Canton
cargo generate --git cw-template
Create project
vim src/contract.rs
Write contracts
cargo wasm && optimizer
Build WASM
cargo test
Run unit tests
wasmd tx wasm store
Deploy contract code
wasmd tx wasm instantiate
Create instance