# Module `(iota_identity=0x0)::controller_proposal` - [Struct `ControllerExecution`](#(iota_identity=0x0)_controller_proposal_ControllerExecution) - [Constants](#@Constants_0) - [Function `new`](#(iota_identity=0x0)_controller_proposal_new) - [Function `receive`](#(iota_identity=0x0)_controller_proposal_receive) - [Function `put_back`](#(iota_identity=0x0)_controller_proposal_put_back)

use (iota_identity=0x0)::controller;
use (iota_identity=0x0)::multicontroller;
use (iota_identity=0x0)::permissions;
use iota::address;
use iota::borrow;
use iota::dynamic_field;
use iota::dynamic_object_field;
use iota::event;
use iota::hex;
use iota::object;
use iota::object_bag;
use iota::transfer;
use iota::tx_context;
use iota::vec_map;
use iota::vec_set;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;

## Struct `ControllerExecution` Borrow a given ControllerCap from an Identity for a single transaction.

public struct ControllerExecution has drop, store

Fields

controller_cap: iota::object::ID: ID of the ControllerCap to borrow.
identity: address: The address of the Identity that owns the ControllerCap we are borrowing.

## Constants The received ControllerCap does not match the one specified in the ControllerExecution action.

const EControllerCapMismatch: u64 = 0;

The provided UID is not the UID of the Identity specified in the action.

const EInvalidIdentityUID: u64 = 1;

## Function `new` Returns a new ControllerExecution that - in a Proposal - allows whoever executes it to receive identity's ControllerCap (the one that has ID controller_cap) for the duration of a single transaction.

public fun new(controller_cap: iota::object::ID, identity: address): (iota_identity=0x0)::controller_proposal::ControllerExecution

Implementation

public fun new(controller_cap: ID, identity: address): ControllerExecution {
    ControllerExecution {
        controller_cap,
        identity,
    }
}

## Function `receive` Returns the ControllerCap specified in this action.

public fun receive(self: &mut (iota_identity=0x0)::multicontroller::Action<(iota_identity=0x0)::controller_proposal::ControllerExecution>, identity: &mut iota::object::UID, cap: iota::transfer::Receiving<(iota_identity=0x0)::controller::ControllerCap>): (iota_identity=0x0)::controller::ControllerCap

Implementation

public fun receive(
    self: &mut Action<ControllerExecution>,
    identity: &mut UID,
    cap: Receiving<ControllerCap>,
): ControllerCap {
    assert!(identity.to_address() == self.borrow().identity, EInvalidIdentityUID);
    assert!(cap.receiving_object_id() == self.borrow().controller_cap, EControllerCapMismatch);
    controller::receive(identity, cap)
}

## Function `put_back` Consumes a ControllerExecution action by returning the borrowed ControllerCap to the corresponding Identity.

public fun put_back(action: (iota_identity=0x0)::multicontroller::Action<(iota_identity=0x0)::controller_proposal::ControllerExecution>, cap: (iota_identity=0x0)::controller::ControllerCap)

Implementation

public fun put_back(action: Action<ControllerExecution>, cap: ControllerCap) {
    let ControllerExecution { identity, controller_cap } = action.unwrap();
    assert!(object::id(&cap) == controller_cap, EControllerCapMismatch);
    cap.transfer(identity);
}