¿Cómo verificar si la estructura pertenece a la dirección?

Estoy tratando de crear un contrato inteligente que permita al creador del contrato agregar propiedades de activos y asignarlo a una dirección. Una vez hecho esto, la dirección receptora ahora puede enviarlo a otra dirección, solo si es el propietario actual.

Traté de asignar una estructura 'Activo' asignando una dirección al ID de activo, que es el recuento de activos que se están creando.

No estoy realmente seguro de si es el enfoque correcto para hacerlo. También estoy un poco confundido sobre cómo puedo verificar el propietario actual en función de AssetId (ya que no hay una cláusula de ubicación como en c # / LINQ). Y cuál sería la forma correcta de asignar un activo del propietario actual al próximo propietario.

pragma solidity ^0.4.2;

contract AssetDistribution { 
address public issuer;
uint public assetCount;

event AllocationDetails(address from, address to, string description);

function AssetDistribution() {
    issuer = msg.sender;
    //ContractorDetails(issuer);
}

struct Asset {
    uint assetId;
    address currentOwner;
    string description;
    uint cost;
}
mapping (address=> mapping(uint=>Asset)) private owners;
//mapping(address=> mapping(uint=>bool)) private ownerPropertyCheck;

//creates an asset and allocates it to an address at the same time. 

function setCreateAsset(address newOwner, string description, uint cost) 
    returns(string) {
    if (msg.sender == issuer) {
    assetCount++;
    Asset memory myAsset = Asset(assetCount,newOwner,description,cost);      
    owners[newOwner][assetCount] = myAsset;
    AllocationDetails(msg.sender,newOwner,description);
    return "created By: government";
    //return strConcat("created By: ","test");
    } else { 
        return "This is not the creator";
    }
}

function getassetCount() constant returns(uint) {
    return assetCount;
}

function getOwner(uint id) returns(address) {
   //return
}

}

En C #, habría creado principalmente una clase con propiedades de activos y habría cambiado el propietario actual cuando se realiza una transferencia. Aquí tengo problemas para acercarme de una manera similar. ¿Debería usar struct para esto?

Edit One - Solución para mí

mapear el ID de activo a la dirección del propietario y direcciones de mapeo + ID de activo a estructuras resolvió el dilema que estaba teniendo

mapping(uint=>address) assetAddress;
mapping(address=>mapping(uint=>Asset)) ownerAssets ;

devuelve la dirección del propietario actual del activo

function getCurrentOwner(uint assetId) constant public returns (address) {
    return assetAddress[assetId];
}

comprueba si el assetId (Id de estructura) pertenece a la dirección

function isOwnerOfAsset(address userId, uint assetId) private constant returns(bool) {
    return assetAddress[assetId] == userId? true:false;
}

PD He codificado principalmente en C#/Backend, saltar a la solidez me confunde un poco. Si conoce algún buen recurso para consultar, siéntase libre de compartirlo.