Method initialize_sc

runners/proxy/ProxyRunner.cpp:584–635

}

void ProxyRunner::initialize_sc(std::shared_ptr<RunnerConfig> snapshot_runner_config,
                                const ton::BlockIdExt &sc_init_block_id, td::Promise<td::Unit> promise) {
  sc_is_initializing_ = true;
  class Cb : public ProxyContract::Callback {
   public:
    Cb(ProxyRunner *self) : self_(self) {
    }
    void on_deploy() override {
    }
    void on_client_update(const block::StdAddress &client_owner_address, const block::StdAddress &client_sc_address,
                          td::uint32 state, td::int64 new_balance, td::int64 new_stake, td::int64 tokens_used,
                          const td::Bits256 &secret_hash) override {
      self_->on_client_update(client_owner_address, client_sc_address, state, new_balance, new_stake, tokens_used,
                              secret_hash);
    }
    void on_client_register(const block::StdAddress &client_owner_address, const block::StdAddress &client_sc_address,
                            td::uint64 nonce) override {
      self_->on_client_register(client_owner_address, client_sc_address, nonce);
    }
    void on_worker_update(const block::StdAddress &worker_owner_address, const block::StdAddress &worker_sc_address,
                          td::uint32 state, td::int64 tokens) override {
      self_->on_worker_update(worker_owner_address, worker_sc_address, state, tokens);
    }
    void on_worker_payout(const block::StdAddress &worker_owner_address, const block::StdAddress &worker_sc_address,
                          td::int64 tokens_delta) override {
    }
    void proxy_save_state(td::int32 seqno, const td::Bits256 &unique_hash) override {
      self_->on_receive_saved_state_seqno(seqno, unique_hash);
    }
    void on_transaction(const block::StdAddress &src_address, td::uint32 op, td::uint64 qid) override {
      self_->on_receive_transaction(src_address, op, qid);
    }

   private:
    ProxyRunner *self_;
  };
  sc_ = std::make_shared<ProxyContract>(owner_address_, public_key_, std::make_unique<Cb>(this), this,
                                        snapshot_runner_config);
  sc_->set_init_block_id(sc_init_block_id);
  sc_->subscribe_to_updates(sc_);

  cocoon_wallet_initialize_wait_for_balance_and_get_seqno(
      wallet_private_key_->as_octet_string(), owner_address_, min_wallet_balance(),
      [self_id = actor_id(this), addr = sc_->address().rserialize(true),
       promise = std::move(promise)](td::Result<td::Unit> R) mutable {
        if (R.is_error()) {
          promise.set_error(R.move_as_error());
          return;
        }
        td::actor::send_closure(self_id, &ProxyRunner::deploy_proxy_sc, std::move(addr), std::move(promise));
      });
}

void ProxyRunner::deploy_proxy_sc(std::string sc_address, td::Promise<td::Unit> promise) {
  if (!sc_ || sc_->address().rserialize(true) != sc_address) {