Связь устройств через контракты.

Правило живёт в TON

Контракт первого устройства шлёт сообщение контракту второго, второй проверяет отправителя и меняет своё состояние. Правило исполняется само, без сервера посередине, и каждый его запуск остаётся в истории контракта. Отправка оплачивается газом (комиссией сети) с баланса контракта-отправителя.

Правило живёт в своём коде

Скрипт читает события первого устройства через HTTP API ноды и отдаёт команду второму. Реакция мгновенная, менять логику можно хоть каждый день, но работает она ровно столько, сколько работает сервер разработчика. Рецепты — на странице «События устройства».

Способы выбираются по цене ошибки. Правило, которое должно сработать даже когда чужой сервер выключен, стоит того, чтобы жить в TON. Остальное дешевле держать в скрипте.

Сценарий для примера: камера у гаража заметила движение ночью и отправляет сигнал alarm. Второе устройство по этому сигналу встаёт на замок — флаг lock, при котором агент перестаёт исполнять команды. Все фрагменты ниже добавляются в контракт устройства services/ton/src/Device.tact.

Шаг 1 — описать сообщение

Сообщение — это структура с именем и полями. Поле at — время отправки по часам блокчейна: по нему получатель отличает свежий сигнал от повтора и от сообщения, которое пришло с опозданием. Собственный счётчик тут не годится: при переносе хранилища он начинается заново, и получатель, у которого записан прежний номер, замолчит навсегда. Время такой ловушки не создаёт.

// Сигнал соседнему устройству.
message DeviceSignal {
    name: String;       // что произошло: "alarm", "overheat", "gone"
    at: Int as uint32;  // время отправки по часам блокчейна
}

// Подписанные команды: отправить сигнал, править список, сменить адресата.
message SendSignal {
    name: String;
}

message SetPeer {
    peer: Address;
    allowed: Bool;
}

message SetSignalTarget {
    target: Address;
}

Шаг 2 — завести поля в хранилище

Всё состояние связи живёт в одном новом поле — структуре под ссылкой. Так сделано не для красоты: у контракта устройства почти исчерпан запас газа на распаковку хранилища в тот момент, когда подпись ещё не проверена. Несколько отдельных полей добавляют работы ровно в этом месте, и подписанные команды перестают приниматься — включая саму команду обновления кода, то есть контракт становится неуправляемым навсегда. Одна ссылка распаковывается лениво и в этот бюджет не лезет.

Поле дописывается в самый конец хранилища, после storageVersion, и заполняется в init. Как переносить хранилище на уже задеплоенном устройстве — в разделе «Обновление кода».

// Всё состояние связи — в одной структуре.
struct SignalState {
    peers: map<Address, Bool>;        // кто вправе слать сигналы
    peerCount: Int as uint8;
    lastSeen: map<Address, Int as uint32>; // время последнего принятого сигнала
    target: Address?;                 // кому это устройство шлёт свой сигнал
}

// В хранилище контракта — ОДНО новое поле, последним:
signal: SignalState?;

Шаг 3 — принять сигнал

Единственное доказательство отправителя в TON — адрес, с которого пришло сообщение: подделать его нельзя. Приёмник ставится выше общего receive(_: Slice) {} в конце контракта, иначе сообщение попадёт в него и будет проглочено.

// Константы объявляются ВНУТРИ contract Device, рядом с остальными:
const ErrorPeerNotAllowed: Int = 3101;
const ErrorNoSignalTarget: Int = 3102;
const ErrorTooManyPeers: Int = 3103;
const MAX_PEERS: Int = 8;
const SIGNAL_VALUE: Int = ton("0.02");

receive(msg: DeviceSignal) {
    let st = self.signal;
    // 1. Отправитель должен быть в списке разрешённых.
    throwUnless(self.ErrorPeerNotAllowed, st != null && st!!.peers.exists(sender()));
    let state = st!!;

    // 2. Повтор и отставший сигнал отбрасываем — но с ошибкой, а не молча:
    //    отказ виден в истории контракта, а тихий пропуск не виден никому.
    let seen = state.lastSeen.get(sender());
    throwUnless(self.ErrorPeerNotAllowed, seen == null || msg.at > seen!!);
    state.lastSeen.set(sender(), msg.at);
    self.signal = state;

    // 3. Реакция: встать на замок и записать событие.
    if (msg.name == "alarm") {
        self.lock = true;
        emit(DeviceEvent {
            contractAddress: myAddress(),
            name: "locked_by_peer",
        }.toCell());
    }
}

emit кладёт событие в историю контракта. Имя пишется своё, а структура берётся готовая — DeviceEvent: её нода уже умеет разбирать, поэтому событие появится в консоли и в ответе GET /events/Device/… без единой правки на стороне ноды.

Шаг 4 — отправить сигнал и настроить список

Отправку и список разрешённых отправителей заводят как обычные команды устройства — те же подписанные сообщения, что SetLock или SetEvents. Разбор команд лежит в dispatchSignedMessage, туда добавляются три ветки. Но отправка сигнала тратит деньги с баланса контракта, поэтому её нельзя пускать по общей проверке: команды устройства принимает и владелец с ограниченными правами, а он не должен уметь отправлять средства на выбранный им же адрес. Право на отправку закрывается тем же гейтом, что и замена кода — только ключ устройства или владелец с полными правами.

// В dispatchSignedMessage — рядом с остальными командами:
if (op == SendSignal.opcode()) {
    self.doSendSignal(SendSignal.fromCell(message).name);
    return;
}
if (op == SetPeer.opcode()) {
    let m = SetPeer.fromCell(message);
    self.doSetPeer(m.peer, m.allowed);
    return;
}
if (op == SetSignalTarget.opcode()) {
    self.doSetTarget(SetSignalTarget.fromCell(message).target);
    return;
}

// Денежные команды — по строгим правам. Проверка стоит в beforeSignedMessage:
// она выполняется уже ПОСЛЕ приёма сообщения, где газа достаточно.
override fun beforeSignedMessage(msg: SignedMessage) {
    let op = msg.message.beginParse().loadUint(32);
    if (op == Upgrade.opcode() ||
        op == SendSignal.opcode() ||
        op == SetSignalTarget.opcode()) {
        self.requireFullOrDeviceKey(msg.publicKey);
    }
}

fun doSendSignal(name: String) {
    let st = self.signal;
    throwUnless(self.ErrorNoSignalTarget, st != null && st!!.target != null);
    send(SendParameters {
        to: st!!.target!!,
        value: self.SIGNAL_VALUE,
        bounce: true,   // не дошло — деньги и остаток газа вернутся отправителю
        mode: SendPayFwdFeesSeparately,
        body: DeviceSignal { name, at: now() }.toCell(),
    });
}

fun emptyState(): SignalState {
    return SignalState { peers: emptyMap(), peerCount: 0, lastSeen: emptyMap(), target: null };
}

fun doSetPeer(peer: Address, allowed: Bool) {
    let state = self.signal == null ? self.emptyState() : self.signal!!;
    if (allowed) {
        if (!state.peers.exists(peer)) {
            throwUnless(self.ErrorTooManyPeers, state.peerCount < self.MAX_PEERS);
            state.peers.set(peer, true);
            state.peerCount = state.peerCount + 1;
        }
    } else if (state.peers.exists(peer)) {
        state.peers.del(peer);
        state.lastSeen.del(peer); // иначе вернувшийся сосед будет заглушён старой отметкой
        state.peerCount = state.peerCount - 1;
    }
    self.signal = state;
}

fun doSetTarget(target: Address) {
    let state = self.signal == null ? self.emptyState() : self.signal!!;
    state.target = target;
    self.signal = state;
}

Список разрешённых отправителей ограничен восемью адресами. Ограничение здесь не формальность: перебор карты стоит газа, а газ платит контракт устройства из своего баланса.