# Clona il repository ufficiale
git clone https://github.com/pontes-veneto/core.git
cd core

# Installa le dipendenze
npm install

# Configura l'ambiente
cp .env.example .env
# Modifica .env con le tue chiavi

import { createTransaction, signTransaction, broadcast } from '@waves/waves-transactions';
import { libs } from '@waves/waves-transactions';

const NODE_URL = 'https://nodes.wavesnodes.com';

// Chiavi dei membri del consorzio (2 su 3)
const member1Seed = 'seed-membro-1';
const member2Seed = 'seed-membro-2';
const member3Seed = 'seed-membro-3';

const members = [
  libs.crypto.publicKey(member1Seed),
  libs.crypto.publicKey(member2Seed),
  libs.crypto.publicKey(member3Seed)
];

// Script multisig 2-of-3
const multisigScript = `
let alice = base58'${members[0]}'
let bob = base58'${members[1]}'
let carol = base58'${members[2]}'

let aliceSigned = sigVerify(tx.bodyBytes, tx.proofs[0], alice)
let bobSigned = sigVerify(tx.bodyBytes, tx.proofs[1], bob)
let carolSigned = sigVerify(tx.bodyBytes, tx.proofs[2], carol)

(aliceSigned && bobSigned) || (aliceSigned && carolSigned) || (bobSigned && carolSigned)
`;

// Transazione per impostare lo script multisig
async function setMultisigScript(seed: string) {
  const setScriptTx = createTransaction({
    type: 13, // SetScript
    version: 2,
    script: multisigScript,
    fee: 1000000,
    chainId: 'W'
  }, seed);

  const signedTx = signTransaction(setScriptTx, seed);
  const result = await broadcast(signedTx, NODE_URL);
  console.log('Multisig script impostato:', result.id);
}

setMultisigScript(member1Seed);

interface PaymentParams {
  recipient: string;
  amount: number;
  assetId?: string;
  attachment?: string;
}

function buildPaymentUrl(params: PaymentParams): string {
  const baseUrl = 'https://multisig.envlab.eu/';
  const recno = 'd4e5f6a7b8c9';

  const queryParams = new URLSearchParams({
    recno,
    recipient: params.recipient,
    amount: params.amount.toString(),
    assetId: params.assetId || '',
    attachment: params.attachment || ''
  });

  return `${baseUrl}?${queryParams.toString()}`;
}

// Esempio: pagamento di 100 ZVD a un fornitore
const paymentUrl = buildPaymentUrl({
  recipient: '3PM1Zb4vsWTVYBhcXmZ443gpPZsA2U4zTVM',
  amount: 100,
  assetId: 'ZVD',
  attachment: 'Fattura-2026-001'
});

console.log('URL di pagamento:', paymentUrl);

async function automatePayment(
  tradeId: string,
  amount: number,
  recipient: string,
  memberSeeds: string[]
) {
  const transferTx = createTransaction({
    type: 4, // Transfer
    version: 2,
    recipient: recipient,
    amount: amount * 100000000, // Importo in satoshi ZVD
    assetId: 'ZVD',
    fee: 100000,
    attachment: `DvP-${tradeId}`
  }, memberSeeds[0]);

  let signedTx = transferTx;
  for (const seed of memberSeeds) {
    signedTx = signTransaction(signedTx, seed);
  }

  const result = await broadcast(signedTx, 'https://nodes.wavesnodes.com');
  console.log('Pagamento inviato:', result.id);

  await registerDvPHash(tradeId, result.id);
}

async function registerDvPHash(tradeId: string, txHash: string) {
  const response = await fetch('https://api.pontesveneto.eu/eii/v1/trades/register', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      tradeId,
      externalTxHash: txHash,
      chain: 'waves',
      timestamp: Date.now()
    })
  });
  return response.json();
}

interface BridgeRequest {
  sourceChain: 'waves' | 'pontes';
  targetChain: 'waves' | 'pontes';
  amount: number;
  recipient: string;
  txHash: string;
}

async function bridgeTransfer(request: BridgeRequest) {
  const isValid = await verifyTransaction(request.txHash, request.sourceChain);
  if (!isValid) {
    throw new Error('Transazione non valida');
  }

  if (request.sourceChain === 'waves') {
    await lockWavesFunds(request.txHash);
  }

  const releaseTx = await releasePontesFunds(
    request.recipient,
    request.amount,
    request.txHash
  );

  await logBridgeOperation({
    ...request,
    releaseTxHash: releaseTx,
    timestamp: Date.now()
  });

  return releaseTx;
}

# Smart contract per la gestione di un consorzio di filiera
# con autorizzazione 2-su-3

let consorzio = base58'3PM1Zb4vslwTVYBcXmZ443gpPZsAZU4zTVM'
let membro1 = base58'3P2H9Y7gXbN4vK8jL6mQ1wS3cD5fG7hJ9k'
let membro2 = base58'3P4R6tY8uI0oP2a54dF6gH8jK0lM2nB4v'
let membro3 = base58'3P5T7yU9i01pQ3sD5fG7hJ9kL1mN3bV5c'

let firma1 = sigVerify(tx.bodyBytes, tx.proofs[0], membro1)
let firma2 = sigVerify(tx.bodyBytes, tx.proofs[1], membro2)
let firma3 = sigVerify(tx.bodyBytes, tx.proofs[2], membro3)

let autorizzato = (firma1 && firma2) || (firma1 && firma3) || (firma2 && firma3)
let destinazioneValida = tx.recipient == consorzio
let fee0k = tx.fee <= 1000000

autorizzato && destinazioneValida && fee0k

async function onboardUser(userData: {
  nome: string;
  cognome: string;
  codiceFiscale: string;
  email: string;
}) {
  const kycResult = await verifyKYC(userData.codiceFiscale);
  if (!kycResult.approved) {
    throw new Error('KYC non superato');
  }

  const seed = generateSeed();
  const publicKey = libs.crypto.publicKey(seed);
  const address = libs.crypto.address(seed, 'W');

  const walletConfig = {
    seed: encryptSeed(seed, userData.codiceFiscale),
    address,
    publicKey,
    kycHash: kycResult.hash,
    createdAt: Date.now()
  };

  await registerUserOnPontes(address, kycResult.hash);
  await sendWelcomeEmail(userData.email, walletConfig);

  return walletConfig;
}

async function fundUserWallet(
  userAddress: string,
  amount: number,
  purpose: string
) {
  const reserveBalance = await getReserveBalance();
  if (reserveBalance < amount) {
    throw new Error('Riserva insufficiente');
  }

  const mintTx = await mintZVD(userAddress, amount, purpose);
  await recordMint(mintTx.id, amount, purpose);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

/**
 * @title ZVDToken
 * @notice Token ERC-20 per lo Zecchino Veneto Digitale v5.0.
 * Integra Sovereign Substrate per compliance check e
 * Sovereign Identity per autenticazione.
 * Valore 1:1 con l'Euro per decisione del Governatore
 * del Banco Nazionale Veneto.
 */
contract ZVDToken is ERC20, AccessControl, Pausable {

    bytes32 public constant MINTER_ROLE      = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE      = keccak256("BURNER_ROLE");
    bytes32 public constant COMPLIANCE_ROLE  = keccak256("COMPLIANCE_ROLE");
    bytes32 public constant PAUSER_ROLE      = keccak256("PAUSER_ROLE");
    bytes32 public constant CASH_TOKEN_ROLE  = keccak256("CASH_TOKEN_ROLE");
    bytes32 public constant SOVEREIGN_ROLE   = keccak256("SOVEREIGN_ROLE");

    mapping(address => bool)    public frozen;
    mapping(address => bytes32) public sovereignDID;

    event AccountFrozen(address indexed account, bool status);
    event Mint(address indexed to, uint256 amount);
    event Burn(address indexed from, uint256 amount);
    event CashTokenIssued(address indexed to, uint256 amount);
    event CashTokenRedeemed(address indexed from, uint256 amount);
    event SovereignDIDLinked(address indexed account, bytes32 did);

    constructor(address admin)
        ERC20("Zecchino Veneto Digitale", "ZVD")
    {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(MINTER_ROLE, admin);
        _grantRole(BURNER_ROLE, admin);
        _grantRole(COMPLIANCE_ROLE, admin);
        _grantRole(PAUSER_ROLE, admin);
        _grantRole(CASH_TOKEN_ROLE, admin);
        _grantRole(SOVEREIGN_ROLE, admin);
    }

    function mint(address to, uint256 amount)
        external onlyRole(MINTER_ROLE) whenNotPaused
    {
        _mint(to, amount);
        emit Mint(to, amount);
    }

    function burn(address from, uint256 amount)
        external onlyRole(BURNER_ROLE)
    {
        _burn(from, amount);
        emit Burn(from, amount);
    }

    function issueCashToken(address to, uint256 amount)
        external onlyRole(CASH_TOKEN_ROLE) whenNotPaused
    {
        _mint(to, amount);
        emit CashTokenIssued(to, amount);
    }

    function redeemCashToken(address from, uint256 amount)
        external onlyRole(CASH_TOKEN_ROLE)
    {
        _burn(from, amount);
        emit CashTokenRedeemed(from, amount);
    }

    function linkSovereignDID(address account, bytes32 did)
        external onlyRole(SOVEREIGN_ROLE)
    {
        sovereignDID[account] = did;
        emit SovereignDIDLinked(account, did);
    }

    function freeze(address account, bool status)
        external onlyRole(COMPLIANCE_ROLE)
    {
        frozen[account] = status;
        emit AccountFrozen(account, status);
    }

    function pause()   external onlyRole(PAUSER_ROLE) { _pause(); }
    function unpause() external onlyRole(PAUSER_ROLE) { _unpause(); }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override whenNotPaused {
        require(!frozen[from] && !frozen[to], "ZVD: account congelato");
        super._beforeTokenTransfer(from, to, amount);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

/**
 * @title ZecchinoVenetoDvP
 * @notice Regolamento atomico DvP/PvP con Hash-Link Protocol sovrano.
 * @dev Integra Trusted Oracle sovrano (NASI), SSI per autenticazione,
 * compliance check automatico e dispute resolution on-chain.
 */
contract ZecchinoVenetoDvP is ReentrancyGuard, AccessControl, Pausable {
    using SafeERC20 for IERC20;

    bytes32 public constant ARBITER_ROLE     = keccak256("ARBITER_ROLE");
    bytes32 public constant OPERATOR_ROLE    = keccak256("OPERATOR_ROLE");
    bytes32 public constant HASH_LINK_ROLE   = keccak256("HASH_LINK_ROLE");
    bytes32 public constant T2_TRIGGER_ROLE  = keccak256("T2_TRIGGER_ROLE");
    bytes32 public constant NASI_ROLE        = keccak256("NASI_ROLE");

    enum TradeStatus {
        None, Initiated, HashLocked, ApprovedBuyer,
        ApprovedSeller, Settled, Cancelled, Expired, Disputed
    }

    struct Trade {
        address buyer;
        address seller;
        uint256 amountZec;
        bytes32 assetHash;
        bytes32 hashLock;
        uint64  timeLock;
        string  assetDescription;
        TradeStatus status;
        uint64  initiatedAt;
        uint64  settledAt;
        bool    t2Settlement;
        bytes32 buyerDID;
        bytes32 sellerDID;
    }

    mapping(bytes32 => Trade) public trades;
    mapping(bytes32 => bool)  public revealedSecrets;
    mapping(bytes32 => bytes32) public disputeEvidence;

    IERC20 public immutable zecToken;
    uint256 public constant DEFAULT_TIMEOUT = 7 days;

    event TradeInitiated(bytes32 indexed tradeId, address indexed buyer, address indexed seller, uint256 amountZec, bytes32 assetHash);
    event HashLocked(bytes32 indexed tradeId, bytes32 hashLock, uint64 timeLock);
    event SecretRevealed(bytes32 indexed tradeId, bytes32 secret);
    event TradeSettled(bytes32 indexed tradeId, uint256 amountZec, bool t2);
    event TradeCancelled(bytes32 indexed tradeId, address indexed by);
    event DisputeOpened(bytes32 indexed tradeId, bytes32 evidenceHash);
    event DisputeResolved(bytes32 indexed tradeId, bool settled);

    constructor(
        address _zecToken,
        address _admin,
        address _arbiter
    ) {
        require(_zecToken != address(0), "Token invalid");
        zecToken = IERC20(_zecToken);
        _grantRole(DEFAULT_ADMIN_ROLE, _admin);
        _grantRole(ARBITER_ROLE, _arbiter);
    }

    function initiateTrade(
        bytes32 tradeId,
        address seller,
        uint256 amountZec,
        bytes32 assetHash,
        bytes32 hashLock,
        uint64  timeLock,
        string calldata assetDescription,
        bool t2Settlement
    ) external nonReentrant onlyRole(OPERATOR_ROLE) whenNotPaused {
        require(trades[tradeId].status == TradeStatus.None, "Trade ID esistente");
        require(seller != address(0) && seller != msg.sender, "Seller non valido");
        require(amountZec > 0, "Importo nullo");
        require(hashLock != bytes32(0), "HashLock mancante");
        require(timeLock > block.timestamp, "TimeLock scaduto");

        zecToken.safeTransferFrom(msg.sender, address(this), amountZec);

        trades[tradeId] = Trade({
            buyer: msg.sender,
            seller: seller,
            amountZec: amountZec,
            assetHash: assetHash,
            hashLock: hashLock,
            timeLock: timeLock,
            assetDescription: assetDescription,
            status: TradeStatus.Initiated,
            initiatedAt: uint64(block.timestamp),
            settledAt: 0,
            t2Settlement: t2Settlement,
            buyerDID: bytes32(0),
            sellerDID: bytes32(0)
        });

        emit TradeInitiated(tradeId, msg.sender, seller, amountZec, assetHash);
    }

    function revealSecret(bytes32 tradeId, bytes32 secret)
        external nonReentrant
    {
        Trade storage t = trades[tradeId];
        require(t.status == TradeStatus.HashLocked, "Stato non valido");
        require(
            keccak256(abi.encodePacked(secret)) == t.hashLock,
            "Secret non valido"
        );
        require(block.timestamp <= t.timeLock, "TimeLock scaduto");

        revealedSecrets[tradeId] = true;
        t.status = TradeStatus.ApprovedSeller;
        emit SecretRevealed(tradeId, secret);
    }

    function emergencyCancel(bytes32 tradeId)
        external nonReentrant onlyRole(ARBITER_ROLE)
    {
        Trade storage t = trades[tradeId];
        require(
            t.status != TradeStatus.Settled &&
            t.status != TradeStatus.Cancelled &&
            t.status != TradeStatus.None,
            "Non cancellable"
        );
        t.status = TradeStatus.Cancelled;
        zecToken.safeTransfer(t.buyer, t.amountZec);
        emit TradeCancelled(tradeId, msg.sender);
    }

    function pause()   external onlyRole(DEFAULT_ADMIN_ROLE) { _pause(); }
    function unpause() external onlyRole(DEFAULT_ADMIN_ROLE) { _unpause(); }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

/**
 * @title BridgeHTLC
 * @notice Bridge HTLC per interoperabilità tra Pontes Veneto e T2 RTGS.
 * Integra Sovereign Link Protocol e Multisig EnvLab (Waves).
 */
contract BridgeHTLC is AccessControl, ReentrancyGuard {
    bytes32 public constant OPERATOR_ROLE        = keccak256("OPERATOR_ROLE");
    bytes32 public constant T2_RELAYER_ROLE      = keccak256("T2_RELAYER_ROLE");
    bytes32 public constant SOVEREIGN_LINK_ROLE  = keccak256("SOVEREIGN_LINK_ROLE");
    bytes32 public constant MULTISIG_BRIDGE_ROLE = keccak256("MULTISIG_BRIDGE_ROLE");

    struct HTLC {
        address sender;
        address receiver;
        uint256 amount;
        bytes32 hashLock;
        uint64  timeLock;
        bool    claimed;
        bool    refunded;
        bool    sovereignLink;
        bytes32 wavesTxHash;
    }

    mapping(bytes32 => HTLC) public htlcs;

    event HTLCCreated(bytes32 indexed htlcId, address indexed sender, address indexed receiver, uint256 amount, bytes32 hashLock, uint64 timeLock);
    event HTLCClaimed(bytes32 indexed htlcId, bytes32 secret);
    event HTLCRefunded(bytes32 indexed htlcId);
    event T2TriggerRelayed(bytes32 indexed htlcId, bytes32 t2TxHash);
    event SovereignLinkEstablished(bytes32 indexed htlcId);
    event WavesMultisigLinked(bytes32 indexed htlcId, bytes32 wavesTxHash);

    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(OPERATOR_ROLE, admin);
        _grantRole(T2_RELAYER_ROLE, admin);
        _grantRole(SOVEREIGN_LINK_ROLE, admin);
        _grantRole(MULTISIG_BRIDGE_ROLE, admin);
    }

    function createHTLC(
        bytes32 htlcId,
        address receiver,
        uint256 amount,
        bytes32 hashLock,
        uint64  timeLock,
        bool    useSovereignLink
    ) external onlyRole(OPERATOR_ROLE) {
        require(htlcs[htlcId].sender == address(0), "HTLC esistente");
        require(receiver != address(0), "Receiver invalido");
        require(amount > 0, "Importo nullo");
        require(timeLock > block.timestamp, "TimeLock scaduto");

        htlcs[htlcId] = HTLC({
            sender: msg.sender,
            receiver: receiver,
            amount: amount,
            hashLock: hashLock,
            timeLock: timeLock,
            claimed: false,
            refunded: false,
            sovereignLink: useSovereignLink,
            wavesTxHash: bytes32(0)
        });

        emit HTLCCreated(htlcId, msg.sender, receiver, amount, hashLock, timeLock);
        if (useSovereignLink) {
            emit SovereignLinkEstablished(htlcId);
        }
    }

    function claimHTLC(bytes32 htlcId, bytes32 secret)
        external nonReentrant
    {
        HTLC storage h = htlcs[htlcId];
        require(!h.claimed && !h.refunded, "HTLC non attivo");
        require(keccak256(abi.encodePacked(secret)) == h.hashLock, "Secret non valido");
        require(block.timestamp <= h.timeLock, "TimeLock scaduto");
        require(msg.sender == h.receiver, "Non autorizzato");

        h.claimed = true;
        emit HTLCClaimed(htlcId, secret);
    }

    function relayT2Trigger(bytes32 htlcId, bytes32 t2TxHash)
        external onlyRole(T2_RELAYER_ROLE)
    {
        emit T2TriggerRelayed(htlcId, t2TxHash);
    }

    function linkWavesMultisig(bytes32 htlcId, bytes32 wavesTxHash)
        external onlyRole(MULTISIG_BRIDGE_ROLE)
    {
        htlcs[htlcId].wavesTxHash = wavesTxHash;
        emit WavesMultisigLinked(htlcId, wavesTxHash);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/AccessControl.sol";

/**
 * @title SovereignIdentity
 * @notice Registro SSI per DID/VC secondo standard W3C.
 * Ogni utente mantiene il controllo della propria identità.
 */
contract SovereignIdentity is AccessControl {
    bytes32 public constant ISSUER_ROLE  = keccak256("ISSUER_ROLE");
    bytes32 public constant REVOKER_ROLE = keccak256("REVOKER_ROLE");

    struct DIDDocument {
        address owner;
        string  did;
        bytes32 publicKeyHash;
        uint64  created;
        uint64  updated;
        bool    active;
    }

    struct VerifiableCredential {
        bytes32 id;
        bytes32 didHash;
        bytes32 credentialHash;
        string  credentialType;
        uint64  issuedAt;
        uint64  expiresAt;
        bool    revoked;
    }

    mapping(bytes32 => DIDDocument) public dids;
    mapping(bytes32 => VerifiableCredential) public credentials;
    mapping(address => bytes32) public addressToDID;

    event DIDCreated(bytes32 indexed didHash, address indexed owner, string did);
    event DIDUpdated(bytes32 indexed didHash, bytes32 newPublicKeyHash);
    event DIDDeactivated(bytes32 indexed didHash);
    event CredentialIssued(bytes32 indexed vcId, bytes32 didHash, string credentialType);
    event CredentialRevoked(bytes32 indexed vcId);

    constructor(address admin) {
        _grantRole(DEFAULT_ADMIN_ROLE, admin);
        _grantRole(ISSUER_ROLE, admin);
        _grantRole(REVOKER_ROLE, admin);
    }

    function createDID(
        bytes32 didHash,
        address owner,
        string calldata did,
        bytes32 publicKeyHash
    ) external onlyRole(ISSUER_ROLE) {
        require(dids[didHash].created == 0, "DID già esistente");
        require(owner != address(0), "Owner invalido");

        dids[didHash] = DIDDocument({
            owner: owner,
            did: did,
            publicKeyHash: publicKeyHash,
            created: uint64(block.timestamp),
            updated: uint64(block.timestamp),
            active: true
        });
        addressToDID[owner] = didHash;

        emit DIDCreated(didHash, owner, did);
    }

    function issueCredential(
        bytes32 vcId,
        bytes32 didHash,
        bytes32 credentialHash,
        string calldata credentialType,
        uint64 expiresAt
    ) external onlyRole(ISSUER_ROLE) {
        require(dids[didHash].active, "DID non attivo");
        require(expiresAt > block.timestamp, "Scadenza non valida");

        credentials[vcId] = VerifiableCredential({
            id: vcId,
            didHash: didHash,
            credentialHash: credentialHash,
            credentialType: credentialType,
            issuedAt: uint64(block.timestamp),
            expiresAt: expiresAt,
            revoked: false
        });

        emit CredentialIssued(vcId, didHash, credentialType);
    }

    function revokeCredential(bytes32 vcId) external onlyRole(REVOKER_ROLE) {
        credentials[vcId].revoked = true;
        emit CredentialRevoked(vcId);
    }
}

# Clona il repository ufficiale
git clone https://github.com/pontes-veneto/core.git
cd core

# Installa le dipendenze
npm install

# Configura l'ambiente
cp .env.example .env
# Modifica .env con le tue chiavi

PONTES_NETWORK=testnet
PONTES_CHAIN_ID=8140
PONTES_RPC_URL=https://rpc-testnet.pontesveneto.eu
WAVES_NODE_URL=https://nodes-testnet.wavesnodes.com
BANCO_VENETO_API=https://api.banconevento.eu/v1

# Compila e distribuisci i contratti Solidity
npx hardhat compile
npx hardhat run scripts/deploy.js --network pontes-testnet

# Output atteso:
# ZVDToken deployed at: 0x...
# ZecchinoVenetoDvP deployed at: 0x...
# SovereignIdentity deployed at: 0x...

import { PontesClient } from '@pontes-veneto/sdk';

const client = new PontesClient({
  rpcUrl: 'https://rpc-testnet.pontesveneto.eu',
  chainId: 8140
});

async function primaTransazione() {
  // 1. Crea o importa un wallet
  const wallet = await client.createWallet();
  console.log('Wallet:', wallet.address);

  // 2. Collega l'identità sovrana
  await wallet.linkSovereignDID({
    jurisdiction: 'IT-VE',
    credentialType: 'Citizen'
  });

  // 3. Ricevi 100 ZVD di benvenuto (solo testnet)
  await client.faucet.request(wallet.address, 100);

  // 4. Effettua un pagamento
  const tx = await wallet.pay({
    to: '0x742d35Cc6634C0532925a3b8444Bc9e7595f0bEb',
    amount: 25.50,
    memo: 'Caffè e brioche'
  });

  console.log('Transazione completata in', tx.finalityMs, 'ms');
}