Обновляемые смарт-контракты в сети Ethereum26.12.2017 22:48

habr.png

Мотивация


Контракты сети Ethereum иммутабельны — единожды загруженные в сети (блокчейн), они не могут быть изменены. Специфика бизнеса или разработки могут потребовать обновить код, но при традиционном подходе это становится проблемой.


Популярные причины необходимости обновления


  • Ошибки в коде
  • Изменение бизнес требований
  • Принятие предложений сообщества об изменении работы контракта


Описание технического решения


Реализация требуемого функционала — обновление кода, планируется через разделение кода на составляющие:


  1. Данные — смарт-контракты без логики и предоставляющие исключительно пространство для хранения данных;
  2. Бизнес-логика — смарт-контракты описывающие логику извлечения данных из хранилища и их изменения;
  3. Входные точки — иммутабельные контракты ведут учет обновления бизнес-логики и предоставляют конечному пользователю ссылку на актуальный контракт бизнес-логики


Обновляемый смарт-контракт счетчика


Представим абстрактный оторванный от реальности пример — счетчик с обновляемой логикой увеличения.


  • Стадия 1. С каждым вызовом счетчик увеличивается на 1
  • Стадия 2. С каждым вызовом счетчик увеличивается на 10


При традиционном подходе и изначальном знании о всех стадиях, было бы необходимо сделать в счетчике поле явно указывающее текущую стадию, например: uint public currentState. При каждом вызове метода увеличения счетчика происходила бы проверка текущей стадии и выполнялся код ассоциированной с ней: 


function increaseCounter() public returns (uint) {
  if (currentState == 0) {
    value = value + 1;
  } else if (currentState == 1) {
    value = value + 10;
  }

  return value;
}


Чтобы наглядно продемонстрировать возможности обновляемых контрактов, согласимся, что у нас появится 3-ая стадия о которой мы пока не знаем и ее условия опишем в конце статьи.


Хранилище


Для реализации слоя данных хранящего текущее значение счетчика и отделенного от бизнес-логики, создаем контракт — ~/contracts/base/UIntStorage.sol:


Source Url


pragma solidity ^0.4.18;

contract UIntStorage {
  uint private value;

  function setValue(uint _value) external returns (uint) {
    value = _value;
    return value;
  }

  function getValue() external view returns (uint) {
    return value;
  }
}


Как видно из названия и реализации контракта — хранилище ничего не знает о том как его будут использовать и выполняет задачу инкапсуляции поля uint private value


Бизнес-логика


Договоримся, что взаимодействие с нашей бизнес-логикой будет осуществляться через два метода: increaseCounter и getCounter для увеличения счетчика и получения текущего значения соответственно, о чем явно опишем в интерфейсе — ~/contracts/examples/counter/ICounter.sol:


Source Url


pragma solidity ^0.4.18;

interface ICounter {
  function increaseCounter() public returns (uint);
  function getCounter() public view returns (uint);
}


Далее опишем смарт-контракт бизнес-логики из первой стадии реализующий ICounter интерфейс и использующий ранее описанное хранилище — ~/contracts/examples/counter/IncrementCounter.sol:


Source Url


pragma solidity ^0.4.18;

import "./ICounter.sol";
import "../../base/UIntStorage.sol";

contract IncrementCounter is ICounter {
  UIntStorage public counter;
  function IncrementCounter(address _storage) public {
    counter = UIntStorage(_storage);
  }
  function increaseCounter() public returns (uint) {
    return counter.setValue(getCounter() + 1);
  }
  function getCounter() public view returns (uint) {
    return counter.getValue();
  }
}


Важно отметить, что IncrementCounter не имеет внутреннего состояния (не хранит данные), кроме ссылки на хранилище.


Если договориться передавать в метод increaseCounter и getCounter ссылку на хранилище первым аргуметом, можно реализовать стейт-лесс бизнес-логику


Вносим изменения в ~/contracts/examples/counter/ICounter.sol:


Source Url


pragma solidity ^0.4.18;

interface ICounter {
  function increaseCounter(address _storage) public returns (uint);
  function getCounter(address _storage) public view returns (uint);
  function validateStorage(address _storage) public view returns (bool);
}


Теперь методы бизнес-логики ждут первым агрументом ссылку на хранилище, а так же реализуют метод проверки хранилища на валидность: validateStorage(address _storage)


Внесем изменения в реализацию первой стадии — ~/contracts/examples/counter/IncrementCounter.sol:
Source Url


pragma solidity ^0.4.18;

import "./ICounter.sol";
import "../../base/UIntStorage.sol";

contract IncrementCounter is ICounter {
  modifier validStorage(address _storage) {
    require(validateStorage(_storage));
    _;
  }

  function increaseCounter(address _storage) 
    validStorage(_storage) 
    public returns (uint) 
  {
    UIntStorage counter = UIntStorage(_storage);
    require(counter.isUIntStorage());
    return counter.setValue(counter.getValue() + 1);
  }

  function getCounter(address _storage) 
    validStorage(_storage) 
    public view returns (uint) 
  {
    UIntStorage counter = UIntStorage(_storage);
    require(counter.isUIntStorage());
    return counter.getValue();
  }

  function validateStorage(address _storage) 
    public view returns (bool) 
  {
    return UIntStorage(_storage).isUIntStorage();
  }
}


Перед переходом к реализации следующей стадии и обновлению контракта бизнес-логики, напишем пару тестов и убедимся, что бизнес-логика работает как запланировано.


Тестирование


Данный репозиторий является проектом фреймворка Truffle и предоставляет удобный функционал для тестирования: truffle test.


Я не буду подробно описывать процесс написания тестов, но если эта тема вам интересна — напишите мне в телеграм @alerdenisov и я подготовлю статью с best-practice тестирования контрактов.


~/test/IncrementCounter.test.js: 


import expectThrow from './utils/expectThrow'

const IncrementCounter = artifacts.require('./IncrementCounter.sol')
const UIntStorage = artifacts.require('./UIntStorage.sol')
const BoolStorage = artifacts.require('./BoolStorage.sol')

contract('IncrementCounter', ([owner, user]) => {
  let counter, storage, fakeStorage
  before(async () => {
    storage = await UIntStorage.new()
    fakeStorage = await BoolStorage.new()
    counter = await IncrementCounter.new()
  })

  it('Should receive 0 at begin', async () => {
    const currentValue = await counter.getCounter(storage.address)
    assert(currentValue.eq(0), `Uxpected counter value: ${currentValue.toString(10)}`)
  })

  it('Should increase value on 1', async () => {
    await counter.increaseCounter(storage.address)
    const newValue = await counter.getCounter(storage.address)
    assert(newValue.eq(1), `Unxpected counter value: ${newValue.toString(10)}`)
  })

  it('Should store 1 after increment', async () => {
    const storedValue = await storage.getValue()
    assert(storedValue.eq(1), `Unxpected stored value: ${storedValue.toString(10)}`)
  })

  it('Should validate storage', async () => {
    await counter.validateStorage(storage.address)
  })

  it('Should unvalidate fake storage', async () => {
    await expectThrow(counter.validateStorage(fakeStorage.address))
  })
})


Запуск тестов покажет, что все «прекрасно»: 


  Contract: IncrementCounter
    ✓ Should receive 0 at begin
    ✓ Should increase value on 1 (63ms)
    ✓ Should store 1 after increment
    ✓ Should validate storage
    ✓ Should unvalidate fake storage

  5 passing (301 ms)


Но на самом деле это не так. Допишем промежуточный тест «неавторизированного» взаимодействия с хранилищем: 


  it('Should prevent non-authenticated write', async () => {
    await expectThrow(storage.setValue(100))
  })


  Contract: IncrementCounter
    ✓ Should receive 0 at begin
    ✓ Should increase value on 1 (58ms)
    1) Should prevent non-authenticated write
    2) Should store 1 after increment
    ✓ Should validate storage
    ✓ Should unvalidate fake storage

  4 passing (330ms)
  2 failing


Source Url


Владение хранилищем


Проблема текущего решения в том, что хранилище никак не ограничивает запись и злоумышленик может изменить данные в хранилище игнорирую бизнес-логику контракта счетчика.


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


Задача сделать так, чтобы изменять хранилище мог исключительно актуальный контракт бизнес-логики.


Для явного ограничения взаимодействия с хранилищем, воспользуемся паттерном Ownable из фреймворка zeppelin-solidity (подробнее c паттерном можно ознакомиться в документации к фреймворку).


Наследуем хранилище от Ownable контракта и добавим модификатор onlyOwner на метод setValue():


Source Url


pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";

contract UIntStorage is Ownable {
  uint private value;

  function setValue(uint _value) onlyOwner external returns (uint) {
    value = _value;
    return value;
  }

  function getValue() external view returns (uint) {
    return value;
  }

  function isUIntStorage() external pure returns (bool) {
    return true;
  }
}


Поздравляю, теперь в наше хранилище может писать только ассоциированный владелец хранилища! Теперь уже 3 из 6 теста проваливаются! Давайте в тестах «в ручную» передадим бизнес-логики управление хранилищем:


Source Url


  before(async () => {
    storage = await UIntStorage.new()
    fakeStorage = await BoolStorage.new()
    counter = await IncrementCounter.new()

    await storage.transferOwnership(counter.address)
  })


Теперь все тесты проходят, но встает второй вопрос: «Как управлять владением хранилища при обновлении бизнес-логики»


Общий контроллер


Перед реализацией общего контроллера сделаем еще один контракт счетчика, но уже второй стадии — ~/contracts/examples/counter/IncrementCounterPhaseTwo.sol:


Source Url


pragma solidity ^0.4.18;

import "./IncrementCounter.sol";

contract IncrementCounterPhaseTwo is IncrementCounter {
  function increaseCounter(address _storage) 
    validStorage(_storage) 
    public returns (uint) 
  {
    UIntStorage counter = UIntStorage(_storage);
    return counter.setValue(counter.getValue() + 10);
  }
}


Теперь когда у нас есть две реализации счетчика и Ownable хранилище, становится понятно, что необходимо как-то «просить» одну реализацию отдать другой управление хранилищем. Добавим метод transferStorage(address _storage, address _counter) в интерфейс счетчиков — ~/contracts/examples/counter/ICounter.sol:


Source Url


pragma solidity ^0.4.18;

interface ICounter {
  function increaseCounter(address _storage) public returns (uint);

  function getCounter(address _storage) public view returns (uint);

  function validateStorage(address _storage) public view returns (bool);

  function transferStorage(address _storage, address _counter) public returns (bool);
}


Договоримся, что финальная реализация ICounter должна после вызова метода transferStorage отдавать управление хранилищем адресу переданному в параметр _counter:


Source Url


  function transferStorage(address _storage, address _counter) validStorage(_storage) public returns (bool) {
    return UIntStorage(_storage).transferOwnership(_counter);
  }


Давайте допишем тесты передачи прав новой логике и проверим результат increaseCounter метода после смены логики: 


  it('Should transfer ownership', async () => {
    await counter.transferStorage(storage.address, secondCounter.address);
  })

  it('Should reject increase from outdated counter', async () => {
    await expectThrow(counter.increaseCounter(storage.address));
  })

  it('Should increase counter with new logic', async () => {
    await secondCounter.increaseCounter(storage.address)
    const newValue = await secondCounter.getCounter(storage.address)
    assert(newValue.eq(11), `Unxpected counter value: ${newValue.toString(10)}`)
  })


Выполнение тестов может дать ложное ощущение, что все работает: 


  Contract: IncrementCounter
    ✓ Should receive 0 at begin
    ✓ Should increase value on 1 (75ms)
    ✓ Should prevent non-authenticated write
    ✓ Should store 1 after increment
    ✓ Should validate storage
    ✓ Should unvalidate fake storage
    ✓ Should transfer ownership
    ✓ Should reject increase from outdated counter
    ✓ Should increase counter with new logic (47ms)

  9 passing (500ms)


Но спешу вас огорчить, эти изменения опять открыли зеленный свет злоумышленикам: 


  it('Should reject non-authenticated transfer storage', async () => {
    await expectThrow(secondCounter.transferStorage(storage.address, user, { from: user }))
  })

  it('Should reject increase from user fron previous test', async () => {
    await expectThrow(storage.setValue(100500, { from: user }))
  })

  it('Should store 11 as before', async () => {
    const storedValue = await storage.getValue()
    assert(storedValue.eq(11), `Unxpected stored value: ${storedValue.toString(10)}`)
  })


  Contract: IncrementCounter
    ✓ Should receive 0 at begin (46ms)
    ✓ Should increase value on 1 (55ms)
    ✓ Should prevent non-authenticated write
    ✓ Should store 1 after increment
    ✓ Should validate storage
    ✓ Should unvalidate fake storage
    ✓ Should transfer ownership
    ✓ Should reject increase from outdated counter
    ✓ Should increase counter with new logic (46ms)
    1) Should reject non-authenticated transfer storage
    2) Should reject increase from user fron previous test
    3) Should store 11 as before

  9 passing (611ms)
  3 failing


Основная задача общего контроллера будет управлять передачей прав и не допускать кого-угодно к этому процессу. Сначала изменим IncrementCounter по аналогии с UIntStorage, чтобы он тоже наследовал логику Ownable и ограничивал взаимодействие с хранилищем:


Source Url


pragma solidity ^0.4.18;

import "./ICounter.sol";
import "../../base/UIntStorage.sol";

contract IncrementCounter is ICounter, Ownable {
  modifier validStorage(address _storage) {
    require(validateStorage(_storage));
    _;
  }

  function increaseCounter(address _storage) 
    onlyOwner validStorage(_storage) 
    public returns (uint) 
  {
    UIntStorage counter = UIntStorage(_storage);
    require(counter.isUIntStorage());
    return counter.setValue(counter.getValue() + 1);
  }

  function getCounter(address _storage) 
    validStorage(_storage) 
    public view returns (uint) 
  {
    UIntStorage counter = UIntStorage(_storage);
    require(counter.isUIntStorage());
    return counter.getValue();
  }

  function validateStorage(address _storage) 
    public view returns (bool) 
  {
    return UIntStorage(_storage).isUIntStorage();
  }

  function transferStorage(address _storage, address _counter)
    onlyOwner validStorage(_storage) 
    public returns (bool) 
  {
    UIntStorage(_storage).transferOwnership(_counter);
    return true;
  }
}


Приступим к реализации контроллера. Основные требования к контроллеру:
1) Учет текущей реализации счетчика
2) Обновление реализации счетчика
2) Перемещение прав на хранилище при обновлении реализации
3) Отклонение попыток неавторизированного обновление реализации


~/contracts/examples/counter/CounterContrller.sol:


Source Url


pragma solidity ^0.4.18;

import "zeppelin-solidity/contracts/ownership/Ownable.sol";
import "./ICounter.sol";
import "../../base/UIntStorage.sol";

contract CounterController is Ownable {
  UIntStorage public store = new UIntStorage();

  ICounter public counter;

  event CounterUpdate(address previousCounter, address nextCounter);

  function updateCounter(address _counter) 
    onlyOwner
    public returns (bool) 
  {
    if (address(counter) != 0x0) {
      counter.transferStorage(store, _counter);
    } else {
      store.transferOwnership(_counter);
    }

    CounterUpdate(counter, _counter);
    counter = ICounter(_counter);
  }

  function increaseCounter() public returns (uint) {
    return counter.increaseCounter(store);
  }

  function getCounter() public view returns (uint) {
    return counter.getCounter(store);
  }
}


increaseCounter и getCounter не более, чем просто внешние методы взаимодействия с аналогичными в текущей реализации ICounter. Вся логика контроллера находится в небольшом методе: updateCounter(address _counter).


Метод updateCounter принимает адресс на реализацию счетчика и перед установкой его как адреса новой реализации счетчика? передает ему права на хранилище (от себя или от предыдущей в зависимости от состояния).


Помните про третью стадию? Я опущу код ее реализации, тем более, что отличается от второй только одной строчкой. Просто скажу, что в третьей стадии счетчик будет увеличивать значение умножением на самого себя: value = value * value.


Давайте напишем немного тестов и убедимся, что контроллер работает и выполняет поставленные перед ним задачи: 


import expectThrow from './utils/expectThrow'

const IncrementCounter = artifacts.require('./IncrementCounter.sol')
const IncrementCounterPhaseTwo = artifacts.require('./IncrementCounterPhaseTwo.sol')
const MultiplyCounterPhaseThree = artifacts.require('./MultiplyCounterPhaseThree.sol')
const CounterController = artifacts.require('./CounterController.sol')
const UIntStorage = artifacts.require('./UIntStorage.sol')

contract('CounterController', ([owner, user]) => {
  let controller, counterOne, counterTwo, counterThree, storage

  before(async () => {
    controller = await CounterController.new()
    storage = UIntStorage.at(await controller.store())
    counterOne = await IncrementCounter.new()
    counterTwo = await IncrementCounterPhaseTwo.new()
    counterThree = await MultiplyCounterPhaseThree.new()

    await counterOne.transferOwnership(controller.address)
    await counterTwo.transferOwnership(controller.address)
    await counterThree.transferOwnership(controller.address)
  })

  it('Shoult create storage', async () => {
    assert(await storage.isUIntStorage(), 'Controller doesn\'t create proper storage')
  })

  it('Should change counter implementation', async () => {
    await controller.updateCounter(counterOne.address)
    assert(await controller.counter() === counterOne.address, `Unxpected counter in controller (${await controller.counter()} but expect ${counterOne.address})`)
  })

  it('Should increase counter on 1', async () => {
    await controller.increaseCounter()
    const value = await controller.getCounter()
    assert(value.eq(1), `Unxpected counter value: ${value.toString(10)}`)
  })

  it('Should update counter', async () => {
    await controller.updateCounter(counterTwo.address)
    assert(await controller.counter() === counterTwo.address, `Unxpected counter in controller (${await controller.counter()} but expect ${counterTwo.address})`)
  })

  it('Should increase counter on 10 after update', async () => {
    await controller.increaseCounter()
    const value = await controller.getCounter()
    assert(value.eq(11), `Unxpected counter value: ${value.toString(10)}`)
  })

  it('Should reject non-authenticated update', async () => {
    await expectThrow(controller.updateCounter(counterTwo.address, { from: user }))
  })

  it('Should update on phase three and increase counter to 11*11 after execution', async () => {
    await controller.updateCounter(counterThree.address)
    await controller.increaseCounter()
    const value = await controller.getCounter()
    assert(value.eq(121), `Unxpected counter value: ${value.toString(10)}`)
  })
})



  Contract: CounterController
    ✓ Shoult create storage
    ✓ Should change counter implementation (53ms)
    ✓ Should increase counter on 1 (52ms)
    ✓ Should update counter (55ms)
    ✓ Should increase counter on 10 after update (56ms)
    ✓ Should reject non-authenticated update
    ✓ Should update on phase three and increase counter to 11*11 after execution (89ms)

  7 passing (684ms)


Как видите контроллер свою задачу выполняет, а код нашего счетчика стал обновляемым.


Резюме

Не смотря на абстрактность (и абсурдность) примера, подход можно применять в реальных контрактах. Например, для обеспечения обновляемости игровой логики в проекте Evogame, я использую данный подход в контрактах реализующих карты монстров, логику боя и т.д.


Но у данного подхода есть ряд существенных недостатков и комментариев:


  • Увеличивается стоимость транзакций (объем потребляемого газа), но не значительно. Если есть желающие провести подсчеты — буду признателен или ожидайте в ближайшем будущем от меня.
  • Появляется роль администратора, но решается передачей прав на контроллер смарт-контракту децентрализованного голосования за принятие обносвлений
  • Сложность проектирования, писать код в одном монолитном контексте в разы проще и требует меньше внимания к потокам данных и сообщений. Реализация state-less требует еще большего внимания от разработчика. Решается вызовом реализации через delegatecall. Напишите мне если нужно написать продолжение с передачей состояния через delegatecall.


UPD:
@dzentota в телеграм обсуждении отметил недоработку: лишний вызов isUIntStorage() в методах IncrementCounter. (Исправление)[https://github.com/alerdenisov/upgradable-contracts/blob/master/contracts/examples/counter/IncrementCounter.sol]

© Habrahabr.ru