diff --git a/readme.md b/readme.md
index 6216bd9..c201704 100644
--- a/readme.md
+++ b/readme.md
@@ -9,9 +9,7 @@ Using this package allows you to call things like admin functions in Pact from y
 
 > If your users have to sign a command, something like Kadena.js would still be required on the frontend. This is not a complete replacement.
 
-> ⚠️ This package is under active development and has only been released under versions 0.x.x to allow for testing of the Package. During development, breaking changes might be made in minor version upgrades.
-> 
-> Some features like adding capabilities are still missing.
+> ⚠️ This package is under active development and has no stable production release yet
 
 ## Installation
 
@@ -26,22 +24,11 @@ composer require kadena-php/client
 Key Pairs are used to sign your Pact commands. You can generate a new KeyPair using
 
 ```php
-$keyPair = \Kadena\Crypto\KeyPair::generate();
+$keyPair = KeyFactory::generate();
 ```
-### Commands
-Commands are requests sent to the Pact API. 
-They contain a payload, metadata, signers, network id, and a nonce. 
-When creating a command, only the metadata and payload are required. 
-The `networkId` is `null` by default, and when no nonce is set, it will default to the current time.
-
-Signers must be present in a signed command, but using the `getSignedCommand` will take care of that for you.
-
-First, let's create metadata to construct our command:
-
-```php
-$metadata = Meta::create();
-```
-The `create()` method takes an optional array of options, options with their default values are:
+### Metadata
+Every command sent to the Kadena API requires a metadata object to be present. This object can be created manually, or be constructed using the `MetadataFactory`. 
+The factory will set predefined defaults if certain options are no provided. The defaults and options are as follows:
 ```php
 creationTime: Carbon::now(),
 ttl: 7200,
@@ -50,49 +37,77 @@ chainId: '0',
 gasPrice: 1e-8,
 sender: ''
 ```
-Then create a payload:
+If we want to create an object with the default options but on a different chain, we can do it like this:
 ```php
-$executePayload = new Payload(
-    payloadType: PayloadType::EXECUTE,
-    executePayload: new ExecutePayload(
-        code: '(+ 1 2)'
-    )
-);
+$factory = new MetadataFactory();
+$metadata = $factory->withOptions([
+    'chainId' => '1',
+])->make();
+```
+If no custom options are required, you can just call `$factory->make()` to create your `Metadata` object.
+### Signers
+Commands have to be signed before sending them to the Kadena API. To support this, a `Signer` (one or many) has to be created. A signer consists of a public key and optionally a list of capabilities.
 
-$continuePayload = new Payload(
-    payloadType: PayloadType::CONTINUE,
-    executePayload: new ContinuePayload(
-        pactId: 'pact-id',
-        rollback: false,
-        step: 0
-    )
+Let's create a signer with a public key of `example-key` and the `coin.transfer` capability. As a signer can have multiple or no capabilities, all `Capability` objects should be wrapped in a `CapabilityCollection` object:
+```php
+// Just as an example, keys should be created using the KeyFactory
+$publicKey = new PublicKey(new SignaturePublicKey(new HiddenString('example-key')));
+
+$transferCapability = new Capability(
+    name: 'coin.transfer',
+    arguments: [
+        'address-from',
+        'address-to',
+        5
+    ]    
 );
+
+$signer = new Signer(
+    publicKey: $publicKey,
+    capabilities: new CapabilityCollection($transferCapability) 
+)
 ```
-As you can see there are two payload types, an execute and a continue payload. With these metadata and payload classes, we can construct our commands:
+Multiple signers can be wrapped in the `SignerCollection` object.
+
+### Payloads
+Payloads are the code to be executed by pact. There are two types of payloads: and execute and a continue payload.
 ```php
-$executeCommand = new Command(
-    meta: $metadata,
-    payload: $executePyaload
+$executePayload new ExecutePayload(
+    code: '(+ 1 2)'
 );
 
-$continueCommand = new Command(
-    meta: $metadata,
-    payload: $continuePyaload
+$continuePayload =  new ContinuePayload(
+    pactId: 'pact-id',
+    rollback: false,
+    step: 0
 );
 ```
 
-### Signing Commands
-After creating a command, you can sign it using any number of key pairs. To do this, first, create a `KeyPairCollection` from the key pairs you have. This can be a single key pair or many.
+### Commands
+Commands wrap all data sent to the Kadena API, a `Command` object can be created manually, but it is recommended to use the `CommandFactory` for this.
+The factory will set certain defaults, and can be used like this:
 ```php
-$kp1 = KeyPair::generate();
-$kp2 = KeyPair::generate();
+$factory = new CommandFactory();
 
-$keyPairCollection = new KeyPairCollection($kp1, $kp2);
+$factory->withExecutePayload($executePayload)
+    ->withMetadata($metadata)
+    ->withSigners(new SignerCollection($signer))
+    ->withNetworkId('mainnet0')
+    ->withNonce('nonce-string')
+    ->make();
+```
+The `withExecutePayload` or the `withContinuePayload` options are always required to create a `Command` object, but all others are optional.
+
+### Signing Commands
+After creating a command, you can sign it using any number of key pairs. To do this, first, create a `KeyPairCollection` from the key pairs you have. 
+These key pairs should correspond to the signers you added to your account.
+```php
+$kpc = new KeyPairCollection($keypair);
 ```
 
 Now using these key pairs, we can sign the previously created command
 ```php
-$signedCommand = $command->getSignedCommand($keyPairCollection);
+$signedCommand = CommandSigner::sign($command, $kpc);
 ```
 This returns a new instance of a `SignedCommand`
 
@@ -100,12 +115,12 @@ This returns a new instance of a `SignedCommand`
 Instead of signing the command in the backend, a command might be signed elsewhere (user wallet). 
 A signed command can be reconstructed from a valid Pact command string using:
 ```php
-$signedCommand = SignedCommand::fromString($commandString)
+$signedCommand = SignedCommandMapper::fromString($commandString)
 ```
 A signed command can also be cast to a string or an array using
 ```php
-$signedCommand->toString();
-$signedCommand->toArray();
+$commandString = SignedCommandMapper::toString($signedCommand);
+$commandArray = SignedCommandMapper::toArray($signedCommand);
 ```
 
 ### Using the Client
diff --git a/src/Client.php b/src/Client.php
index 2447143..6c447c7 100644
--- a/src/Client.php
+++ b/src/Client.php
@@ -3,11 +3,13 @@
 namespace Kadena;
 
 use JsonException;
-use Kadena\Contracts\Pact as PactContract;
-use Kadena\Pact\RequestKey;
-use Kadena\Pact\RequestKeyCollection;
-use Kadena\Pact\SignedCommand;
-use Kadena\Pact\SignedCommandCollection;
+use Kadena\Contracts\Client as ClientContract;
+use Kadena\DataMappers\SignedCommandCollectionMapper;
+use Kadena\DataMappers\SignedCommandMapper;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+use Kadena\ValueObjects\RequestKey\RequestKey;
+use Kadena\ValueObjects\RequestKey\RequestKeyCollection;
 use Symfony\Component\HttpClient\HttpClient;
 use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
 use Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface;
@@ -17,7 +19,7 @@
 use Symfony\Contracts\HttpClient\HttpClientInterface;
 use Symfony\Contracts\HttpClient\ResponseInterface;
 
-class Client implements PactContract
+class Client implements ClientContract
 {
     private HttpClientInterface $client;
 
@@ -36,11 +38,12 @@ public function __construct(private readonly string $apiUrl, HttpClientInterface
      * @throws RedirectionExceptionInterface
      * @throws DecodingExceptionInterface
      * @throws ClientExceptionInterface
+     * @throws JsonException
      */
     public function send(SignedCommandCollection $commands): RequestKeyCollection
     {
         $response = $this->client->request('POST', $this->apiUrl . '/api/v1/send', [
-            'json' => $commands->toPayload(),
+            'json' => SignedCommandCollectionMapper::toArray($commands),
         ]);
 
         $requestKeys = array_map(static function (string $requestKey) {
@@ -57,7 +60,7 @@ public function send(SignedCommandCollection $commands): RequestKeyCollection
     public function local(SignedCommand $command): ResponseInterface
     {
         return $this->client->request('POST', $this->apiUrl . '/api/v1/local', [
-            'json' => $command->toArray(),
+            'json' => SignedCommandMapper::toArray($command),
         ]);
     }
 
diff --git a/src/Contracts/Pact.php b/src/Contracts/Client.php
similarity index 69%
rename from src/Contracts/Pact.php
rename to src/Contracts/Client.php
index 8738a5f..7dc7f98 100644
--- a/src/Contracts/Pact.php
+++ b/src/Contracts/Client.php
@@ -2,13 +2,13 @@
 
 namespace Kadena\Contracts;
 
-use Kadena\Pact\RequestKey;
-use Kadena\Pact\RequestKeyCollection;
-use Kadena\Pact\SignedCommand;
-use Kadena\Pact\SignedCommandCollection;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+use Kadena\ValueObjects\RequestKey\RequestKey;
+use Kadena\ValueObjects\RequestKey\RequestKeyCollection;
 use Symfony\Contracts\HttpClient\ResponseInterface;
 
-interface Pact
+interface Client
 {
     public function send(SignedCommandCollection $commands): RequestKeyCollection;
 
diff --git a/src/Contracts/Collection.php b/src/Contracts/Collection.php
new file mode 100644
index 0000000..df84e76
--- /dev/null
+++ b/src/Contracts/Collection.php
@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts;
+
+interface Collection
+{
+    public function toArray(): array;
+    public function first(): mixed;
+    public function get(int $offset): mixed;
+}
diff --git a/src/Contracts/Crypto/CommandSigner.php b/src/Contracts/Crypto/CommandSigner.php
new file mode 100644
index 0000000..e66b2f9
--- /dev/null
+++ b/src/Contracts/Crypto/CommandSigner.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\Crypto;
+
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Signer\KeyPairCollection;
+
+interface CommandSigner
+{
+    public static function sign(Command $command, KeyPairCollection $keyPairs): SignedCommand;
+}
diff --git a/src/Crypto/Contracts/Hash.php b/src/Contracts/Crypto/Hash.php
similarity index 76%
rename from src/Crypto/Contracts/Hash.php
rename to src/Contracts/Crypto/Hash.php
index 62ecd64..89859bb 100644
--- a/src/Crypto/Contracts/Hash.php
+++ b/src/Contracts/Crypto/Hash.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Crypto\Contracts;
+namespace Kadena\Contracts\Crypto;
 
 interface Hash
 {
diff --git a/src/Contracts/Crypto/KeyFactory.php b/src/Contracts/Crypto/KeyFactory.php
new file mode 100644
index 0000000..4b66179
--- /dev/null
+++ b/src/Contracts/Crypto/KeyFactory.php
@@ -0,0 +1,10 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\Crypto;
+
+use Kadena\ValueObjects\Signer\KeyPair;
+
+interface KeyFactory
+{
+    public static function generate(): KeyPair;
+}
diff --git a/src/Crypto/Contracts/Signer.php b/src/Contracts/Crypto/MessageSigner.php
similarity index 62%
rename from src/Crypto/Contracts/Signer.php
rename to src/Contracts/Crypto/MessageSigner.php
index bfd2f3b..6b0abdd 100644
--- a/src/Crypto/Contracts/Signer.php
+++ b/src/Contracts/Crypto/MessageSigner.php
@@ -1,18 +1,15 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Crypto\Contracts;
+namespace Kadena\Contracts\Crypto;
 
-use Kadena\Crypto\KeyPair;
-use Kadena\Crypto\Signature;
-use Kadena\Pact\Command;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\Signature;
 use ParagonIE\Halite\Asymmetric\SignaturePublicKey;
 
-interface Signer
+interface MessageSigner
 {
     public static function sign(string $message, KeyPair $keyPair): Signature;
 
-    public static function signCommand(Command $command, KeyPair $keyPair): Signature;
-
     public static function signHash(string $hash, KeyPair $keyPair): Signature;
 
     public static function verifySignature(string $message, string $signature, SignaturePublicKey $publicKey): bool;
diff --git a/src/Contracts/DataMappers/CommandMapper.php b/src/Contracts/DataMappers/CommandMapper.php
new file mode 100644
index 0000000..ae6991d
--- /dev/null
+++ b/src/Contracts/DataMappers/CommandMapper.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\DataMappers;
+
+use Kadena\ValueObjects\Command\Command;
+
+interface CommandMapper
+{
+    public static function toArray(Command $command): array;
+    public static function toString(Command $command): string;
+    public static function fromString(string $commandJson): Command;
+}
diff --git a/src/Contracts/DataMappers/SignedCommandCollectionMapper.php b/src/Contracts/DataMappers/SignedCommandCollectionMapper.php
new file mode 100644
index 0000000..e1092b2
--- /dev/null
+++ b/src/Contracts/DataMappers/SignedCommandCollectionMapper.php
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\DataMappers;
+
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+
+interface SignedCommandCollectionMapper
+{
+    public static function toArray(SignedCommandCollection $commands): array;
+    public static function toString(SignedCommandCollection $commands): string;
+}
diff --git a/src/Contracts/DataMappers/SignedCommandMapper.php b/src/Contracts/DataMappers/SignedCommandMapper.php
new file mode 100644
index 0000000..c1a46f6
--- /dev/null
+++ b/src/Contracts/DataMappers/SignedCommandMapper.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\DataMappers;
+
+use Kadena\ValueObjects\Command\SignedCommand;
+
+interface SignedCommandMapper
+{
+    public static function toArray(SignedCommand $command): array;
+    public static function toString(SignedCommand $command): string;
+    public static function fromString(string $commandJson): SignedCommand;
+}
diff --git a/src/Contracts/Pact/CommandFactory.php b/src/Contracts/Pact/CommandFactory.php
new file mode 100644
index 0000000..c9f871f
--- /dev/null
+++ b/src/Contracts/Pact/CommandFactory.php
@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\Pact;
+
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ContinuePayload;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+
+interface CommandFactory
+{
+    public static function load(Command $command): self;
+    public function addSigner(Signer $signer): self;
+    public function withMetadata(Metadata $metadata): self;
+    public function withExecutePayload(ExecutePayload $payload): self;
+    public function withContinuePayload(ContinuePayload $payload): self;
+    public function withNonce(string $nonce): self;
+    public function withNetworkId(string $networkId): self;
+    public function withSigners(SignerCollection $signers): self;
+    public function make(): Command;
+}
diff --git a/src/Contracts/Pact/MetadataFactory.php b/src/Contracts/Pact/MetadataFactory.php
new file mode 100644
index 0000000..6e5ee0a
--- /dev/null
+++ b/src/Contracts/Pact/MetadataFactory.php
@@ -0,0 +1,11 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Contracts\Pact;
+
+use Kadena\ValueObjects\Command\Metadata;
+
+interface MetadataFactory
+{
+    public function withOptions(array $options): self;
+    public function make(): Metadata;
+}
diff --git a/src/Crypto/CommandSigner.php b/src/Crypto/CommandSigner.php
new file mode 100644
index 0000000..e4ba3bd
--- /dev/null
+++ b/src/Crypto/CommandSigner.php
@@ -0,0 +1,42 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Crypto;
+
+use JsonException;
+use Kadena\Contracts\Crypto\CommandSigner as CommandSignerContract;
+use Kadena\DataMappers\CommandMapper;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\KeyPairCollection;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+use ParagonIE\ConstantTime\Base64UrlSafe;
+use ParagonIE\Halite\Alerts\InvalidType;
+use SodiumException;
+
+final class CommandSigner implements CommandSignerContract
+{
+    /**
+     * @throws InvalidType
+     * @throws SodiumException
+     * @throws JsonException
+     */
+    public static function sign(Command $command, KeyPairCollection $keyPairs): SignedCommand
+    {
+        $commandString = CommandMapper::toString($command);
+        $commandHash = Base64UrlSafe::encodeUnpadded(Hash::generic($commandString));
+
+        $signatures = [];
+
+        /** @var KeyPair $keyPair */
+        foreach ($keyPairs->toArray() as $keyPair) {
+            $signatures[] = MessageSigner::sign($commandString, $keyPair);
+        }
+
+        return new SignedCommand(
+            hash: $commandHash,
+            signatures: new SignatureCollection(...$signatures),
+            command: $command
+        );
+    }
+}
diff --git a/src/Crypto/Contracts/KeyPair.php b/src/Crypto/Contracts/KeyPair.php
deleted file mode 100644
index 26eb7ad..0000000
--- a/src/Crypto/Contracts/KeyPair.php
+++ /dev/null
@@ -1,8 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Crypto\Contracts;
-
-interface KeyPair
-{
-    public static function generate(): self;
-}
diff --git a/src/Crypto/Hash.php b/src/Crypto/Hash.php
index ac3e5ff..c049617 100644
--- a/src/Crypto/Hash.php
+++ b/src/Crypto/Hash.php
@@ -2,7 +2,7 @@
 
 namespace Kadena\Crypto;
 
-use Kadena\Crypto\Contracts\Hash as HashContract;
+use Kadena\Contracts\Crypto\Hash as HashContract;
 use SodiumException;
 
 final class Hash implements HashContract
diff --git a/src/Crypto/KeyFactory.php b/src/Crypto/KeyFactory.php
new file mode 100644
index 0000000..2ad33d7
--- /dev/null
+++ b/src/Crypto/KeyFactory.php
@@ -0,0 +1,29 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Crypto;
+
+use Kadena\Contracts\Crypto\KeyFactory as KeyFactoryContract;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\PublicKey;
+use Kadena\ValueObjects\Signer\SecretKey;
+use ParagonIE\Halite\Alerts\CannotPerformOperation;
+use ParagonIE\Halite\Alerts\InvalidKey;
+use SodiumException;
+
+final class KeyFactory implements KeyFactoryContract
+{
+    /**
+     * @throws InvalidKey
+     * @throws CannotPerformOperation
+     * @throws SodiumException
+     */
+    public static function generate(): KeyPair
+    {
+        $keyPair = \ParagonIE\Halite\KeyFactory::generateSignatureKeyPair();
+
+        return new KeyPair(
+            publicKey: new PublicKey($keyPair->getPublicKey()),
+            secretKey: new SecretKey($keyPair->getSecretKey())
+        );
+    }
+}
diff --git a/src/Crypto/KeyPair.php b/src/Crypto/KeyPair.php
deleted file mode 100644
index 6c1745b..0000000
--- a/src/Crypto/KeyPair.php
+++ /dev/null
@@ -1,35 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Crypto;
-
-use Kadena\Crypto\Contracts\KeyPair as KeyPairContract;
-use ParagonIE\Halite\Alerts\CannotPerformOperation;
-use ParagonIE\Halite\Alerts\InvalidKey;
-use ParagonIE\Halite\Asymmetric\SignaturePublicKey;
-use ParagonIE\Halite\Asymmetric\SignatureSecretKey;
-use ParagonIE\Halite\KeyFactory;
-use SodiumException;
-
-final class KeyPair implements KeyPairContract
-{
-    public function __construct(
-        readonly public SignaturePublicKey $publicKey,
-        readonly public SignatureSecretKey $secretKey,
-    ) {
-    }
-
-    /**
-     * @throws InvalidKey
-     * @throws CannotPerformOperation
-     * @throws SodiumException
-     */
-    public static function generate(): self
-    {
-        $keyPair = KeyFactory::generateSignatureKeyPair();
-
-        return new self(
-            publicKey: $keyPair->getPublicKey(),
-            secretKey: $keyPair->getSecretKey()
-        );
-    }
-}
diff --git a/src/Crypto/KeyPairCollection.php b/src/Crypto/KeyPairCollection.php
deleted file mode 100644
index 44bb5a7..0000000
--- a/src/Crypto/KeyPairCollection.php
+++ /dev/null
@@ -1,24 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Crypto;
-
-final class KeyPairCollection
-{
-    /**
-     * @var KeyPair[]
-     */
-    private array $array;
-
-    public function __construct(KeyPair ...$keyPair)
-    {
-        $this->array = $keyPair;
-    }
-
-    /**
-     * @return KeyPair[]
-     */
-    public function toArray(): array
-    {
-        return $this->array;
-    }
-}
diff --git a/src/Crypto/Signer.php b/src/Crypto/MessageSigner.php
similarity index 60%
rename from src/Crypto/Signer.php
rename to src/Crypto/MessageSigner.php
index ba02391..22e7874 100644
--- a/src/Crypto/Signer.php
+++ b/src/Crypto/MessageSigner.php
@@ -2,10 +2,10 @@
 
 namespace Kadena\Crypto;
 
-use Kadena\Crypto\Contracts\Signer as SignerContract;
-use Kadena\Pact\Command;
+use Kadena\Contracts\Crypto\MessageSigner as MessageSignerContract;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\Signature;
 use ParagonIE\ConstantTime\Base64UrlSafe;
-use ParagonIE\ConstantTime\Hex;
 use ParagonIE\Halite\Alerts\InvalidSignature;
 use ParagonIE\Halite\Alerts\InvalidType;
 use ParagonIE\Halite\Asymmetric\Crypto;
@@ -13,11 +13,9 @@
 use ParagonIE\Halite\Halite;
 use SodiumException;
 
-final class Signer implements SignerContract
+final class MessageSigner implements MessageSignerContract
 {
     /**
-     * Sign a message given a key pair and return a SignedMessage object
-     *
      * @throws InvalidType
      * @throws SodiumException
      */
@@ -29,25 +27,21 @@ public static function sign(string $message, KeyPair $keyPair): Signature
     }
 
     /**
-     * Sign a hash given a key pair and return a SignedMessage object
-     *
      * @throws InvalidType
      * @throws SodiumException
      */
     public static function signHash(string $hash, KeyPair $keyPair): Signature
     {
-        $signature = Crypto::sign($hash, $keyPair->secretKey, Halite::ENCODE_HEX);
+        $signature = Crypto::sign($hash, $keyPair->secretKey->key, Halite::ENCODE_HEX);
 
         return new Signature(
             hash: Base64UrlSafe::encodeUnpadded($hash),
             signature: $signature,
-            publicKey: Hex::encode($keyPair->publicKey->getRawKeyMaterial())
+            publicKey: $keyPair->publicKey->toString()
         );
     }
 
     /**
-     * Verify a signature given a public key and message
-     *
      * @throws InvalidType
      * @throws InvalidSignature
      * @throws SodiumException
@@ -56,15 +50,4 @@ public static function verifySignature(string $message, string $signature, Signa
     {
         return Crypto::verify($message, $publicKey, $signature, Halite::ENCODE_HEX);
     }
-
-    /**
-     * @throws InvalidType
-     * @throws SodiumException
-     */
-    public static function signCommand(Command $command, KeyPair $keyPair): Signature
-    {
-        $message = $command->toString();
-
-        return self::sign($message, $keyPair);
-    }
 }
diff --git a/src/Crypto/SignatureCollection.php b/src/Crypto/SignatureCollection.php
deleted file mode 100644
index 46a5446..0000000
--- a/src/Crypto/SignatureCollection.php
+++ /dev/null
@@ -1,41 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Crypto;
-
-final class SignatureCollection
-{
-    /**
-     * @var Signature[]
-     */
-    private array $array;
-
-    public function __construct(Signature ...$signature)
-    {
-        $this->array = $signature;
-    }
-
-    public function first(): Signature
-    {
-        return $this->array[0];
-    }
-
-    /**
-     * @return Signature[]
-     */
-    public function toArray(): array
-    {
-        return $this->array;
-    }
-
-    public static function fromArray(array $signatures, string $hash): self
-    {
-        return new self(...array_map(static function (array|object $signature) use ($hash) {
-            $signature = (array) $signature;
-
-            return new Signature(
-                hash: $hash,
-                signature: $signature['sig']
-            );
-        }, $signatures));
-    }
-}
diff --git a/src/DataMappers/CommandMapper.php b/src/DataMappers/CommandMapper.php
new file mode 100644
index 0000000..7979a08
--- /dev/null
+++ b/src/DataMappers/CommandMapper.php
@@ -0,0 +1,199 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\DataMappers;
+
+use Carbon\Carbon;
+use InvalidArgumentException;
+use JsonException;
+use Kadena\Contracts\DataMappers\CommandMapper as CommandMapperContract;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ContinuePayload;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\PublicKey;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+use ParagonIE\ConstantTime\Hex;
+use ParagonIE\Halite\Alerts\InvalidKey;
+use ParagonIE\Halite\Asymmetric\SignaturePublicKey;
+use ParagonIE\HiddenString\HiddenString;
+
+final class CommandMapper implements CommandMapperContract
+{
+    public static function toArray(Command $command): array
+    {
+        if ($command->payload->payloadType === PayloadType::EXECUTE) {
+            $payload = [
+                'data' => $command->payload->executePayload->data,
+                'code' => $command->payload->executePayload->code,
+            ];
+        } else {
+            $payload = [
+                'data' => $command->payload->continuePayload->data,
+                'step' => $command->payload->continuePayload->step,
+                'rollback' => $command->payload->continuePayload->rollback,
+                'pactId' => $command->payload->continuePayload->pactId,
+                'proof' => $command->payload->continuePayload->proof,
+            ];
+        }
+
+        $array = [
+            'networkId' => $command->networkId,
+            'payload' => [
+                $command->payload->payloadType->value => $payload
+            ],
+            'meta' => [
+                'creationTime' => $command->meta->creationTime->getTimestamp(),
+                'ttl' => $command->meta->ttl,
+                'gasLimit' => $command->meta->gasLimit,
+                'chainId' => $command->meta->chainId,
+                'gasPrice' => $command->meta->gasPrice,
+                'sender' => $command->meta->sender,
+            ],
+            'nonce' => $command->nonce
+        ];
+
+        if ($command->signers->count() === 0) {
+            return $array;
+        }
+
+        $signers = [];
+
+        /** @var Signer $signer */
+        foreach ($command->signers->toArray() as $signer) {
+            $signerArray = [
+                'pubKey' => $signer->publicKey->toString(),
+            ];
+
+            if ($signer->capabilities->count() !== 0) {
+                $capabilityList = [];
+
+                /** @var Capability $capability */
+                foreach ($signer->capabilities->toArray() as $capability) {
+                    $capabilityList[] = [
+                        'name' => $capability->name,
+                        'args' => $capability->arguments,
+                    ];
+                }
+
+                $signerArray['clist'] = $capabilityList;
+            }
+
+            $signers[] = $signerArray;
+        }
+
+        $array['signers'] = $signers;
+
+        return $array;
+    }
+
+    /**
+     * @throws JsonException
+     */
+    public static function toString(Command $command): string
+    {
+        return json_encode(self::toArray($command), JSON_THROW_ON_ERROR);
+    }
+
+    /**
+     * @throws JsonException
+     * @throws InvalidKey
+     */
+    public static function fromString(string $commandJson): Command
+    {
+        $command = json_decode($commandJson, false, 512, JSON_THROW_ON_ERROR);
+
+        if (! isset($command->signers, $command->payload, $command->meta)) {
+            throw new InvalidArgumentException('Invalid Command JSON string given');
+        }
+
+        $meta = $command->meta;
+
+        if (! isset(
+            $meta->creationTime,
+            $meta->ttl,
+            $meta->gasLimit,
+            $meta->chainId,
+            $meta->gasPrice,
+            $meta->sender,
+        )) {
+            throw new InvalidArgumentException('Invalid meta object given');
+        }
+
+        $payloadType = PayloadType::from(key((array) $command->payload));
+
+        if ($payloadType === PayloadType::EXECUTE) {
+            $exec = $command->payload->exec;
+
+            if (! isset($exec->data, $exec->code)) {
+                throw new InvalidArgumentException('Invalid execute command object given');
+            }
+
+            $payload = new Payload(
+                payloadType: $payloadType,
+                executePayload: new ExecutePayload(
+                    code: $exec->code,
+                    data: (array) ($exec->data ?? []),
+                )
+            );
+        } elseif ($payloadType === PayloadType::CONTINUE) {
+            $cont = $command->payload->cont;
+
+            if (! isset($cont->data, $cont->code, $cont->pactId, $cont->rollback, $cont->step)) {
+                throw new InvalidArgumentException('Invalid continue command object given');
+            }
+
+            $payload = new Payload(
+                payloadType: $payloadType,
+                continuePayload: new ContinuePayload(
+                    pactId: $cont->pactId,
+                    rollback: $cont->rollback,
+                    step: $cont->step,
+                    proof: $cont->proof ?? null,
+                    data: (array) ($cont->data ?? []),
+                )
+            );
+        } else {
+            throw new InvalidArgumentException('Unknown payload type');
+        }
+
+        $signers = [];
+
+        foreach ($command->signers as $signer) {
+            $capabilities = [];
+
+            if (isset($signer->clist)) {
+                foreach ($signer->clist as $capabilityList) {
+                    $capabilities[] = new Capability(
+                        name: $capabilityList->name,
+                        arguments: $capabilityList->args
+                    );
+                }
+            }
+
+            $signers[] = new Signer(
+                publicKey: new PublicKey(new SignaturePublicKey(new HiddenString(Hex::decode($signer->pubKey)))),
+                capabilities: new CapabilityCollection(...$capabilities)
+            );
+        }
+
+        return new Command(
+            meta: new Metadata(
+                creationTime: Carbon::createFromTimestamp($meta->creationTime),
+                ttl: $meta->ttl,
+                gasLimit: $meta->gasLimit,
+                chainId: $meta->chainId,
+                gasPrice: $meta->gasPrice,
+                sender: $meta->sender
+            ),
+            payload: $payload,
+            networkId: $command->networkId ?? '0',
+            nonce: $command->nonce ?? Carbon::now()->toISOString(),
+            signers: new SignerCollection(...$signers)
+        );
+    }
+}
diff --git a/src/DataMappers/SignedCommandCollectionMapper.php b/src/DataMappers/SignedCommandCollectionMapper.php
new file mode 100644
index 0000000..e768588
--- /dev/null
+++ b/src/DataMappers/SignedCommandCollectionMapper.php
@@ -0,0 +1,31 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\DataMappers;
+
+use JsonException;
+use Kadena\Contracts\DataMappers\SignedCommandCollectionMapper as SignedCommandCollectionMapperContract;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+
+final class SignedCommandCollectionMapper implements SignedCommandCollectionMapperContract
+{
+    /**
+     * @throws JsonException
+     */
+    public static function toArray(SignedCommandCollection $commands): array
+    {
+        return [
+            'cmds' => array_map(static function (SignedCommand $command) {
+                return SignedCommandMapper::toArray($command);
+            }, $commands->toArray())
+        ];
+    }
+
+    /**
+     * @throws JsonException
+     */
+    public static function toString(SignedCommandCollection $commands): string
+    {
+        return json_encode(self::toArray($commands), JSON_THROW_ON_ERROR);
+    }
+}
diff --git a/src/DataMappers/SignedCommandMapper.php b/src/DataMappers/SignedCommandMapper.php
new file mode 100644
index 0000000..50117ae
--- /dev/null
+++ b/src/DataMappers/SignedCommandMapper.php
@@ -0,0 +1,65 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\DataMappers;
+
+use InvalidArgumentException;
+use JsonException;
+use Kadena\Contracts\DataMappers\SignedCommandMapper as SignedCommandMapperContract;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Signer\Signature;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+
+final class SignedCommandMapper implements SignedCommandMapperContract
+{
+    /**
+     * @throws JsonException
+     */
+    public static function toArray(SignedCommand $command): array
+    {
+        return [
+            'cmd' => CommandMapper::toString($command->command),
+            'hash' => $command->hash,
+            'sigs' => array_map(static function (Signature $signature) {
+                return ['sig' => $signature->signature];
+            }, $command->signatures->toArray())
+        ];
+    }
+
+    /**
+     * @throws JsonException
+     */
+    public static function toString(SignedCommand $command): string
+    {
+        return json_encode(self::toArray($command), JSON_THROW_ON_ERROR);
+    }
+
+    /**
+     * @throws JsonException
+     */
+    public static function fromString(string $commandJson): SignedCommand
+    {
+        $command = json_decode($commandJson, false, 512, JSON_THROW_ON_ERROR);
+
+        if (! isset($command->hash, $command->sigs, $command->cmd)) {
+            throw new InvalidArgumentException('Invalid Signed Command JSON string given');
+        }
+
+        return new SignedCommand(
+            hash: $command->hash,
+            signatures: self::getSignatures((array) $command->sigs, $command->hash),
+            command: CommandMapper::fromString($command->cmd),
+        );
+    }
+
+    private static function getSignatures(array $signatures, string $hash): SignatureCollection
+    {
+        return new SignatureCollection(...array_map(static function (array|object $signature) use ($hash) {
+            $signature = (array) $signature;
+
+            return new Signature(
+                hash: $hash,
+                signature: $signature['sig']
+            );
+        }, $signatures));
+    }
+}
diff --git a/src/Exceptions/MissingPayloadException.php b/src/Exceptions/MissingPayloadException.php
new file mode 100644
index 0000000..cf1e859
--- /dev/null
+++ b/src/Exceptions/MissingPayloadException.php
@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Exceptions;
+
+use Exception;
+
+final class MissingPayloadException extends Exception
+{
+}
diff --git a/src/Exceptions/UnknownMetadataException.php b/src/Exceptions/UnknownMetadataException.php
new file mode 100644
index 0000000..48d295a
--- /dev/null
+++ b/src/Exceptions/UnknownMetadataException.php
@@ -0,0 +1,9 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Exceptions;
+
+use Exception;
+
+final class UnknownMetadataException extends Exception
+{
+}
diff --git a/src/Pact/Command.php b/src/Pact/Command.php
deleted file mode 100644
index 30cb2ed..0000000
--- a/src/Pact/Command.php
+++ /dev/null
@@ -1,172 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Pact;
-
-use Carbon\Carbon;
-use InvalidArgumentException;
-use JsonException;
-use Kadena\Crypto\KeyPair;
-use Kadena\Crypto\KeyPairCollection;
-use Kadena\Crypto\SignatureCollection;
-use Kadena\Crypto\Signer;
-use ParagonIE\ConstantTime\Hex;
-use ParagonIE\Halite\Alerts\InvalidType;
-use SodiumException;
-
-final class Command
-{
-    public readonly string $nonce;
-    private array $signers = [];
-
-    public function __construct(
-        public readonly Meta $meta,
-        public readonly Payload $payload,
-        public readonly ?string $networkId = null,
-        ?string $nonce = null,
-    ) {
-        if ($nonce === null) {
-            $this->nonce = Carbon::now()->toISOString();
-        } else {
-            $this->nonce = $nonce;
-        }
-    }
-
-    /**
-     * @throws JsonException
-     */
-    public function toString(): string
-    {
-        return json_encode($this->toArray(), JSON_THROW_ON_ERROR);
-    }
-
-    public function toArray(): array
-    {
-        return [
-            'signers' => $this->signers,
-            'networkId' => $this->networkId,
-            'payload' => $this->payload->toArray(),
-            'meta' => $this->meta->toArray(),
-            'nonce' => $this->nonce,
-        ];
-    }
-
-    /**
-     * @throws InvalidType
-     * @throws SodiumException
-     */
-    public function getSignedCommand(KeyPairCollection $keyPairCollection): SignedCommand
-    {
-        $this->setSigners(array_map([$this, 'getSigners'], $keyPairCollection->toArray()));
-
-        $signatures = [];
-
-        foreach ($keyPairCollection->toArray() as $keyPair) {
-            $signatures[] = Signer::signCommand($this, $keyPair);
-        }
-
-        $signatureCollection = new SignatureCollection(...$signatures);
-
-        return new SignedCommand(
-            hash: $signatureCollection->first()->hash,
-            signatures: $signatureCollection,
-            command: $this
-        );
-    }
-
-    private function getSigners(KeyPair $keyPair): string
-    {
-        return Hex::encode($keyPair->publicKey->getRawKeyMaterial());
-    }
-
-    public function setSigners(array $signers): void
-    {
-        $pubKeys = [];
-
-        foreach ($signers as $signer) {
-            $pubKeys[] = ['pubKey' => $signer];
-        }
-
-        $this->signers = $pubKeys;
-    }
-
-    public static function fromString(string $commandJson): self
-    {
-        $command = json_decode($commandJson, false, 512, JSON_THROW_ON_ERROR);
-
-        if (! isset($command->signers, $command->payload, $command->meta)) {
-            throw new InvalidArgumentException('Invalid Command JSON string given');
-        }
-
-        $meta = $command->meta;
-
-        if (! isset(
-            $meta->creationTime,
-            $meta->ttl,
-            $meta->gasLimit,
-            $meta->chainId,
-            $meta->gasPrice,
-            $meta->sender,
-        )) {
-            throw new InvalidArgumentException('Invalid meta object given');
-        }
-
-        $payloadType = PayloadType::from(key((array) $command->payload));
-
-        if ($payloadType === PayloadType::EXECUTE) {
-            $exec = $command->payload->exec;
-
-            if (! isset($exec->data, $exec->code)) {
-                throw new InvalidArgumentException('Invalid execute command object given');
-            }
-
-            $payload = new Payload(
-                payloadType: $payloadType,
-                executePayload: new ExecutePayload(
-                    code: $exec->code,
-                    data: (array) ($exec->data ?? []),
-                )
-            );
-        } elseif ($payloadType === PayloadType::CONTINUE) {
-            $cont = $command->payload->cont;
-
-            if (! isset($cont->data, $cont->code, $cont->pactId, $cont->rollback, $cont->step)) {
-                throw new InvalidArgumentException('Invalid continue command object given');
-            }
-
-            $payload = new Payload(
-                payloadType: $payloadType,
-                continuePayload: new ContinuePayload(
-                    pactId: $cont->pactId,
-                    rollback: $cont->rollback,
-                    step: $cont->step,
-                    proof: $cont->proof ?? null,
-                    data: (array) ($cont->data ?? []),
-                )
-            );
-        } else {
-            throw new InvalidArgumentException('Unknown payload type');
-        }
-
-        $commandObject = new self(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp($meta->creationTime),
-                ttl: $meta->ttl,
-                gasLimit: $meta->gasLimit,
-                chainId: $meta->chainId,
-                gasPrice: $meta->gasPrice,
-                sender: $meta->sender
-            ),
-            payload: $payload,
-            networkId: $command->networkId ?? null,
-            nonce: $command->nonce ?? null
-        );
-
-        $commandObject->setSigners(array_map(static function (array|object $signer) {
-            $signer = (array) $signer;
-
-            return $signer['pubKey'];
-        }, $command->signers));
-
-        return $commandObject;
-    }
-}
diff --git a/src/Pact/CommandFactory.php b/src/Pact/CommandFactory.php
new file mode 100644
index 0000000..8839ec6
--- /dev/null
+++ b/src/Pact/CommandFactory.php
@@ -0,0 +1,136 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Pact;
+
+use Carbon\Carbon;
+use Kadena\Contracts\Pact\CommandFactory as CommandFactoryContract;
+use Kadena\Exceptions\MissingPayloadException;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ContinuePayload;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+
+final class CommandFactory implements CommandFactoryContract
+{
+    private Metadata $metadata;
+    private Payload $payload;
+    private string $networkId;
+    private string $nonce;
+    private SignerCollection $signers;
+
+    public static function load(Command $command): self
+    {
+        $self = new self();
+
+        if ($command->payload->payloadType === PayloadType::EXECUTE) {
+            $self->withExecutePayload($command->payload->executePayload);
+        }
+
+        if ($command->payload->payloadType === PayloadType::CONTINUE) {
+            $self->withContinuePayload($command->payload->continuePayload);
+        }
+
+        return $self->withSigners($command->signers)
+            ->withNetworkId($command->networkId)
+            ->withNonce($command->nonce)
+            ->withMetadata($command->meta);
+    }
+
+    public function addSigner(Signer $signer): self
+    {
+        if (! isset($this->signers)) {
+            $this->signers = new SignerCollection();
+        }
+
+        $signers = $this->signers->toArray();
+        $signers[] = $signer;
+
+        $this->signers = new SignerCollection(...$signers);
+    }
+
+    public function withMetadata(Metadata $metadata): self
+    {
+        $this->metadata = $metadata;
+
+        return $this;
+    }
+
+    public function withExecutePayload(ExecutePayload $payload): self
+    {
+        $this->payload = new Payload(
+            payloadType: PayloadType::EXECUTE,
+            executePayload: $payload
+        );
+
+        return $this;
+    }
+
+    public function withContinuePayload(ContinuePayload $payload): self
+    {
+        $this->payload = new Payload(
+            payloadType: PayloadType::CONTINUE,
+            continuePayload: $payload
+        );
+
+        return $this;
+    }
+
+    public function withNonce(string $nonce): self
+    {
+        $this->nonce = $nonce;
+
+        return $this;
+    }
+
+    public function withNetworkId(string $networkId): self
+    {
+        $this->networkId = $networkId;
+
+        return $this;
+    }
+
+    public function withSigners(SignerCollection $signers): self
+    {
+        $this->signers = $signers;
+
+        return $this;
+    }
+
+    /**
+     * @throws MissingPayloadException
+     */
+    public function make(): Command
+    {
+        if (! isset($this->payload)) {
+            throw new MissingPayloadException('Payload is required to build command');
+        }
+
+        if (! isset($this->metadata)) {
+            $this->metadata = (new MetadataFactory())->make();
+        }
+
+        if (! isset($this->nonce)) {
+            $this->nonce = Carbon::now()->toISOString();
+        }
+
+        if (! isset($this->networkId)) {
+            $this->networkId = '0';
+        }
+
+        if (! isset($this->signers)) {
+            $this->signers = new SignerCollection();
+        }
+
+        return new Command(
+            meta: $this->metadata,
+            payload: $this->payload,
+            networkId: $this->networkId,
+            nonce: $this->nonce,
+            signers: $this->signers
+        );
+    }
+}
diff --git a/src/Pact/Meta.php b/src/Pact/Meta.php
deleted file mode 100644
index 1a9eab3..0000000
--- a/src/Pact/Meta.php
+++ /dev/null
@@ -1,44 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Pact;
-
-use Carbon\Carbon;
-
-final class Meta
-{
-    private const MIN_GAS_PRICE = 0.00000001;
-
-    public function __construct(
-        public readonly Carbon $creationTime,
-        public readonly int $ttl,
-        public readonly int $gasLimit,
-        public readonly string $chainId,
-        public readonly float $gasPrice,
-        public readonly string $sender,
-    ) {
-    }
-
-    public function toArray(): array
-    {
-        return [
-            'creationTime' => $this->creationTime->getTimestamp(),
-            'ttl' => $this->ttl,
-            'gasLimit' => $this->gasLimit,
-            'chainId' => $this->chainId,
-            'gasPrice' => $this->gasPrice,
-            'sender' => $this->sender,
-        ];
-    }
-
-    public static function create(?array $options = []): self
-    {
-        return new self(
-            creationTime: (isset($options['creationTime'])) ? Carbon::createFromTimestamp((int) $options['creationTime']) : Carbon::now(),
-            ttl: (int) ($options['ttl'] ?? 7200),
-            gasLimit: (int) ($options['gasLimit'] ?? 10000),
-            chainId: (string) ($options['chainId'] ?? '0'),
-            gasPrice: (float) ($options['gasPrice'] ?? self::MIN_GAS_PRICE),
-            sender: (string) ($options['sender'] ?? '')
-        );
-    }
-}
diff --git a/src/Pact/MetadataFactory.php b/src/Pact/MetadataFactory.php
new file mode 100644
index 0000000..f54a9b2
--- /dev/null
+++ b/src/Pact/MetadataFactory.php
@@ -0,0 +1,48 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Pact;
+
+use Carbon\Carbon;
+use Kadena\Contracts\Pact\MetadataFactory as MetadataFactoryContract;
+use Kadena\ValueObjects\Command\Metadata;
+
+final class MetadataFactory implements MetadataFactoryContract
+{
+    private Carbon $creationTime;
+    private int $ttl = 7200;
+    private int $gasLimit = 10000;
+    private string $chainId = '0';
+    private float $gasPrice = 1e-8;
+    private string $sender = '';
+
+    public function withOptions(array $options): self
+    {
+        foreach ($options as $key => $option) {
+            if (in_array($key, array_keys(get_class_vars(self::class)), true)) {
+                if ($key === 'creationTime' && ! is_a($option, Carbon::class)) {
+                    $this->$key = Carbon::createFromTimestamp((int) $option);
+                } else {
+                    $this->$key = $option;
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    public function make(): Metadata
+    {
+        if (! isset($this->creationTime)) {
+            $this->creationTime = Carbon::now();
+        }
+
+        return new Metadata(
+            creationTime: $this->creationTime,
+            ttl: $this->ttl,
+            gasLimit: $this->gasLimit,
+            chainId: $this->chainId,
+            gasPrice: $this->gasPrice,
+            sender: $this->sender
+        );
+    }
+}
diff --git a/src/Pact/RequestKeyCollection.php b/src/Pact/RequestKeyCollection.php
deleted file mode 100644
index 82bd60b..0000000
--- a/src/Pact/RequestKeyCollection.php
+++ /dev/null
@@ -1,36 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Pact;
-
-final class RequestKeyCollection
-{
-    /**
-     * @var RequestKey[]
-     */
-    private array $array;
-
-    public function __construct(RequestKey ...$requestKey)
-    {
-        $this->array = $requestKey;
-    }
-
-    /**
-     * @return RequestKey[]
-     */
-    public function toArray(): array
-    {
-        return $this->array;
-    }
-
-    public function toPlainArray(): array
-    {
-        return array_map(static function (RequestKey $requestKey) {
-            return $requestKey->key;
-        }, $this->array);
-    }
-
-    public function first(): RequestKey
-    {
-        return $this->array[0];
-    }
-}
diff --git a/src/Pact/SignedCommand.php b/src/Pact/SignedCommand.php
deleted file mode 100644
index a286da0..0000000
--- a/src/Pact/SignedCommand.php
+++ /dev/null
@@ -1,71 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Pact;
-
-use InvalidArgumentException;
-use JsonException;
-use Kadena\Crypto\SignatureCollection;
-
-final class SignedCommand
-{
-    public function __construct(
-        public readonly string $hash,
-        public readonly SignatureCollection $signatures,
-        public readonly Command $command,
-    ) {
-        $this->validateSignatures();
-    }
-
-    private function validateSignatures(): void
-    {
-        foreach ($this->signatures->toArray() as $signature) {
-            if ($signature->hash !== $this->hash) {
-                throw new InvalidArgumentException("Signatures for different hashes found: {$signature->hash}, expected: {$this->hash}");
-            }
-        }
-    }
-
-    /**
-     * @throws JsonException
-     */
-    public function toArray(): array
-    {
-        $signatures = [];
-
-        foreach ($this->signatures->toArray() as $signature) {
-            $signatures[] = ['sig' => $signature->signature];
-        }
-
-        return [
-            'hash' => $this->hash,
-            'sigs' => $signatures,
-            'cmd' => $this->command->toString(),
-        ];
-    }
-
-    /**
-     * @throws JsonException
-     */
-    public function toString(): string
-    {
-        return json_encode($this->toArray(), JSON_THROW_ON_ERROR);
-    }
-
-    /**
-     * @throws JsonException
-     */
-    public static function fromString(string $commandJson): self
-    {
-        $command = json_decode($commandJson, false, 512, JSON_THROW_ON_ERROR);
-
-        if (! isset($command->hash, $command->sigs, $command->cmd)) {
-            throw new InvalidArgumentException('Invalid Signed Command JSON string given');
-        }
-
-        return new self(
-            hash: $command->hash,
-            signatures: SignatureCollection::fromArray((array) $command->sigs, $command->hash),
-            command: Command::fromString($command->cmd),
-        );
-    }
-}
diff --git a/src/Pact/SignedCommandCollection.php b/src/Pact/SignedCommandCollection.php
deleted file mode 100644
index ceaf50c..0000000
--- a/src/Pact/SignedCommandCollection.php
+++ /dev/null
@@ -1,51 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Pact;
-
-use JsonException;
-
-final class SignedCommandCollection
-{
-    /**
-     * @var SignedCommand[]
-     */
-    private array $array;
-
-    public function __construct(SignedCommand ...$signedCommand)
-    {
-        $this->array = $signedCommand;
-    }
-
-    /**
-     * @return SignedCommand[]
-     */
-    public function toArray(): array
-    {
-        return $this->array;
-    }
-
-    public function toPayload(): array
-    {
-        $commands = array_map([$this, 'mapToArray'], $this->array);
-
-        return [
-            'cmds' => $commands
-        ];
-    }
-
-    /**
-     * @throws JsonException
-     */
-    public function toPayloadString(): string
-    {
-        return json_encode($this->toPayload(), JSON_THROW_ON_ERROR);
-    }
-
-    /**
-     * @throws JsonException
-     */
-    private function mapToArray(SignedCommand $signedCommand): array
-    {
-        return $signedCommand->toArray();
-    }
-}
diff --git a/src/ValueObjects/Command/Command.php b/src/ValueObjects/Command/Command.php
new file mode 100644
index 0000000..8adb3c3
--- /dev/null
+++ b/src/ValueObjects/Command/Command.php
@@ -0,0 +1,18 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Command;
+
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Signer\SignerCollection;
+
+final class Command
+{
+    public function __construct(
+        public readonly Metadata $meta,
+        public readonly Payload  $payload,
+        public readonly string   $networkId,
+        public readonly string   $nonce,
+        public readonly SignerCollection $signers,
+    ) {
+    }
+}
diff --git a/src/ValueObjects/Command/Metadata.php b/src/ValueObjects/Command/Metadata.php
new file mode 100644
index 0000000..1eb19d1
--- /dev/null
+++ b/src/ValueObjects/Command/Metadata.php
@@ -0,0 +1,18 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Command;
+
+use Carbon\Carbon;
+
+final class Metadata
+{
+    public function __construct(
+        public readonly Carbon $creationTime,
+        public readonly int $ttl,
+        public readonly int $gasLimit,
+        public readonly string $chainId,
+        public readonly float $gasPrice,
+        public readonly string $sender,
+    ) {
+    }
+}
diff --git a/src/Pact/ContinuePayload.php b/src/ValueObjects/Command/Payload/ContinuePayload.php
similarity index 52%
rename from src/Pact/ContinuePayload.php
rename to src/ValueObjects/Command/Payload/ContinuePayload.php
index cf5ae4d..2f58d17 100644
--- a/src/Pact/ContinuePayload.php
+++ b/src/ValueObjects/Command/Payload/ContinuePayload.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Pact;
+namespace Kadena\ValueObjects\Command\Payload;
 
 final class ContinuePayload
 {
@@ -12,15 +12,4 @@ public function __construct(
         public readonly array $data = [],
     ) {
     }
-
-    public function toArray(): array
-    {
-        return [
-            'proof' => $this->proof,
-            'pactId' => $this->pactId,
-            'rollback' => $this->rollback,
-            'step' => $this->step,
-            'data' => $this->data,
-        ];
-    }
 }
diff --git a/src/Pact/ExecutePayload.php b/src/ValueObjects/Command/Payload/ExecutePayload.php
similarity index 52%
rename from src/Pact/ExecutePayload.php
rename to src/ValueObjects/Command/Payload/ExecutePayload.php
index 2ea1e8d..04cacaa 100644
--- a/src/Pact/ExecutePayload.php
+++ b/src/ValueObjects/Command/Payload/ExecutePayload.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Pact;
+namespace Kadena\ValueObjects\Command\Payload;
 
 final class ExecutePayload
 {
@@ -9,12 +9,4 @@ public function __construct(
         public readonly array $data = [],
     ) {
     }
-
-    public function toArray(): array
-    {
-        return [
-            'data' => $this->data,
-            'code' => $this->code,
-        ];
-    }
 }
diff --git a/src/Pact/Payload.php b/src/ValueObjects/Command/Payload/Payload.php
similarity index 79%
rename from src/Pact/Payload.php
rename to src/ValueObjects/Command/Payload/Payload.php
index 5f94b58..4116295 100644
--- a/src/Pact/Payload.php
+++ b/src/ValueObjects/Command/Payload/Payload.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Pact;
+namespace Kadena\ValueObjects\Command\Payload;
 
 use InvalidArgumentException;
 
@@ -30,13 +30,4 @@ private function validate(): void
             throw new InvalidArgumentException('Only continue payload should be provided when type is \'continue\'');
         }
     }
-
-    public function toArray(): array
-    {
-        return [
-            $this->payloadType->value =>
-                $this->executePayload?->toArray()
-                ?? $this->continuePayload->toArray(),
-        ];
-    }
 }
diff --git a/src/Pact/PayloadType.php b/src/ValueObjects/Command/Payload/PayloadType.php
similarity index 71%
rename from src/Pact/PayloadType.php
rename to src/ValueObjects/Command/Payload/PayloadType.php
index 398bfd2..5181286 100644
--- a/src/Pact/PayloadType.php
+++ b/src/ValueObjects/Command/Payload/PayloadType.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Pact;
+namespace Kadena\ValueObjects\Command\Payload;
 
 enum PayloadType: string
 {
diff --git a/src/ValueObjects/Command/SignedCommand.php b/src/ValueObjects/Command/SignedCommand.php
new file mode 100644
index 0000000..bd95ec9
--- /dev/null
+++ b/src/ValueObjects/Command/SignedCommand.php
@@ -0,0 +1,26 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Command;
+
+use InvalidArgumentException;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+
+final class SignedCommand
+{
+    public function __construct(
+        public readonly string $hash,
+        public readonly SignatureCollection $signatures,
+        public readonly Command $command,
+    ) {
+        $this->validateSignatures();
+    }
+
+    private function validateSignatures(): void
+    {
+        foreach ($this->signatures->toArray() as $signature) {
+            if ($signature->hash !== $this->hash) {
+                throw new InvalidArgumentException("Signatures for different hashes found: {$signature->hash}, expected: {$this->hash}");
+            }
+        }
+    }
+}
diff --git a/src/ValueObjects/Command/SignedCommandCollection.php b/src/ValueObjects/Command/SignedCommandCollection.php
new file mode 100644
index 0000000..72535de
--- /dev/null
+++ b/src/ValueObjects/Command/SignedCommandCollection.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Command;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class SignedCommandCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(SignedCommand ...$signedCommand)
+    {
+        $this->array = $signedCommand;
+    }
+}
diff --git a/src/ValueObjects/HasCollectionMethods.php b/src/ValueObjects/HasCollectionMethods.php
new file mode 100644
index 0000000..a5b351e
--- /dev/null
+++ b/src/ValueObjects/HasCollectionMethods.php
@@ -0,0 +1,28 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects;
+
+trait HasCollectionMethods
+{
+    private array $array = [];
+
+    public function toArray(): array
+    {
+        return $this->array;
+    }
+
+    public function first(): mixed
+    {
+        return $this->array[0];
+    }
+
+    public function get(int $offset): mixed
+    {
+        return $this->array[$offset];
+    }
+
+    public function count(): int
+    {
+        return sizeof($this->array);
+    }
+}
diff --git a/src/Pact/RequestKey.php b/src/ValueObjects/RequestKey/RequestKey.php
similarity index 77%
rename from src/Pact/RequestKey.php
rename to src/ValueObjects/RequestKey/RequestKey.php
index 057d231..fd9c79c 100644
--- a/src/Pact/RequestKey.php
+++ b/src/ValueObjects/RequestKey/RequestKey.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Pact;
+namespace Kadena\ValueObjects\RequestKey;
 
 final class RequestKey
 {
diff --git a/src/ValueObjects/RequestKey/RequestKeyCollection.php b/src/ValueObjects/RequestKey/RequestKeyCollection.php
new file mode 100644
index 0000000..d084c07
--- /dev/null
+++ b/src/ValueObjects/RequestKey/RequestKeyCollection.php
@@ -0,0 +1,23 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\RequestKey;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class RequestKeyCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(RequestKey ...$requestKey)
+    {
+        $this->array = $requestKey;
+    }
+
+    public function toPlainArray(): array
+    {
+        return array_map(static function (RequestKey $requestKey) {
+            return $requestKey->key;
+        }, $this->toArray());
+    }
+}
diff --git a/src/ValueObjects/Signer/Capability.php b/src/ValueObjects/Signer/Capability.php
new file mode 100644
index 0000000..cb0e045
--- /dev/null
+++ b/src/ValueObjects/Signer/Capability.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+final class Capability
+{
+    public function __construct(
+        public readonly string  $name,
+        public readonly array   $arguments = [],
+    ) {
+    }
+}
diff --git a/src/ValueObjects/Signer/CapabilityCollection.php b/src/ValueObjects/Signer/CapabilityCollection.php
new file mode 100644
index 0000000..d908054
--- /dev/null
+++ b/src/ValueObjects/Signer/CapabilityCollection.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class CapabilityCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(Capability ...$capabilityDescription)
+    {
+        $this->array = $capabilityDescription;
+    }
+}
diff --git a/src/ValueObjects/Signer/KeyPair.php b/src/ValueObjects/Signer/KeyPair.php
new file mode 100644
index 0000000..fced80f
--- /dev/null
+++ b/src/ValueObjects/Signer/KeyPair.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+final class KeyPair
+{
+    public function __construct(
+        readonly public PublicKey $publicKey,
+        readonly public SecretKey $secretKey,
+    ) {
+    }
+}
diff --git a/src/ValueObjects/Signer/KeyPairCollection.php b/src/ValueObjects/Signer/KeyPairCollection.php
new file mode 100644
index 0000000..4b91ba8
--- /dev/null
+++ b/src/ValueObjects/Signer/KeyPairCollection.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class KeyPairCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(KeyPair ...$keyPair)
+    {
+        $this->array = $keyPair;
+    }
+}
diff --git a/src/ValueObjects/Signer/PublicKey.php b/src/ValueObjects/Signer/PublicKey.php
new file mode 100644
index 0000000..0948a4a
--- /dev/null
+++ b/src/ValueObjects/Signer/PublicKey.php
@@ -0,0 +1,24 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use ParagonIE\ConstantTime\Hex;
+use ParagonIE\Halite\Asymmetric\SignaturePublicKey;
+
+final class PublicKey
+{
+    public function __construct(
+        readonly public SignaturePublicKey $key
+    ) {
+    }
+
+    public function toString(): string
+    {
+        return Hex::encode($this->key->getRawKeyMaterial());
+    }
+
+    public function __toString(): string
+    {
+        return $this->toString();
+    }
+}
diff --git a/src/ValueObjects/Signer/SecretKey.php b/src/ValueObjects/Signer/SecretKey.php
new file mode 100644
index 0000000..b94b10d
--- /dev/null
+++ b/src/ValueObjects/Signer/SecretKey.php
@@ -0,0 +1,13 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use ParagonIE\Halite\Asymmetric\SignatureSecretKey;
+
+final class SecretKey
+{
+    public function __construct(
+        readonly public SignatureSecretKey $key
+    ) {
+    }
+}
diff --git a/src/Crypto/Signature.php b/src/ValueObjects/Signer/Signature.php
similarity index 86%
rename from src/Crypto/Signature.php
rename to src/ValueObjects/Signer/Signature.php
index 4bafdd0..a19b42d 100644
--- a/src/Crypto/Signature.php
+++ b/src/ValueObjects/Signer/Signature.php
@@ -1,6 +1,6 @@
 <?php declare(strict_types=1);
 
-namespace Kadena\Crypto;
+namespace Kadena\ValueObjects\Signer;
 
 final class Signature
 {
diff --git a/src/ValueObjects/Signer/SignatureCollection.php b/src/ValueObjects/Signer/SignatureCollection.php
new file mode 100644
index 0000000..1d8a288
--- /dev/null
+++ b/src/ValueObjects/Signer/SignatureCollection.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class SignatureCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(Signature ...$signature)
+    {
+        $this->array = $signature;
+    }
+}
diff --git a/src/ValueObjects/Signer/Signer.php b/src/ValueObjects/Signer/Signer.php
new file mode 100644
index 0000000..bf009bb
--- /dev/null
+++ b/src/ValueObjects/Signer/Signer.php
@@ -0,0 +1,12 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+final class Signer
+{
+    public function __construct(
+        public readonly PublicKey $publicKey,
+        public readonly CapabilityCollection $capabilities,
+    ) {
+    }
+}
diff --git a/src/ValueObjects/Signer/SignerCollection.php b/src/ValueObjects/Signer/SignerCollection.php
new file mode 100644
index 0000000..13054de
--- /dev/null
+++ b/src/ValueObjects/Signer/SignerCollection.php
@@ -0,0 +1,16 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\ValueObjects\Signer;
+
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+
+final class SignerCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(Signer ...$signer)
+    {
+        $this->array = $signer;
+    }
+}
diff --git a/tests/Unit/ClientTest.php b/tests/Unit/ClientTest.php
index 63f1cdd..5fb4e9a 100644
--- a/tests/Unit/ClientTest.php
+++ b/tests/Unit/ClientTest.php
@@ -4,17 +4,24 @@
 
 use Carbon\Carbon;
 use Kadena\Client;
-use Kadena\Crypto\Signature;
-use Kadena\Crypto\SignatureCollection;
-use Kadena\Pact\Command;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Meta;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use Kadena\Pact\RequestKey;
-use Kadena\Pact\RequestKeyCollection;
-use Kadena\Pact\SignedCommand;
-use Kadena\Pact\SignedCommandCollection;
+use Kadena\Crypto\KeyFactory;
+use Kadena\DataMappers\SignedCommandCollectionMapper;
+use Kadena\DataMappers\SignedCommandMapper;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+use Kadena\ValueObjects\RequestKey\RequestKey;
+use Kadena\ValueObjects\RequestKey\RequestKeyCollection;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\Signature;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\HttpClient\MockHttpClient;
 use Symfony\Component\HttpClient\Response\MockResponse;
@@ -27,8 +34,10 @@ public function setUp(): void
     {
         parent::setUp();
 
+        $keyPair = KeyFactory::generate();
+
         $command = new Command(
-            meta: new Meta(
+            meta: new Metadata(
                 creationTime: Carbon::createFromTimestamp(0),
                 ttl: 0,
                 gasLimit: 0,
@@ -41,26 +50,34 @@ public function setUp(): void
                 executePayload: new ExecutePayload(
                     code: '(+ 2 2)'
                 )
-            )
+            ),
+            networkId: 'testnet0',
+            nonce: 'test',
+            signers: new SignerCollection(new Signer(
+                publicKey: $keyPair->publicKey,
+                capabilities: new CapabilityCollection(
+                    new Capability(
+                        name: 'cap.example',
+                        arguments: []
+                    )
+                )
+            ))
         );
 
-        $command->setSigners(['public-key']);
-
-        $signature = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
+        $this->signedCommand = new SignedCommand(
+            hash: 'test-hash',
+            signatures: new SignatureCollection(new Signature(
+                hash: 'test-hash',
+                signature: 'test-signature'
+            )),
+            command: $command
         );
-
-        $signatures = new SignatureCollection($signature);
-
-        $this->signedCommand = new SignedCommand('hash', $signatures, $command);
     }
 
     /** @test */
     public function it_should_send_a_signed_command_to_the_local_endpoint_and_return_a_response_object(): void
     {
-        $expectedRequestData = $this->signedCommand->toArray();
+        $expectedRequestData = SignedCommandMapper::toArray($this->signedCommand);
 
         $expectedResponseData = [
             'gas' => 123,
@@ -116,7 +133,7 @@ public function it_should_send_a_signed_command_to_the_local_endpoint_and_return
     /** @test */
     public function it_should_send_a_collection_of_signed_commands_to_the_send_endpoint_and_return_a_collection_of_request_keys(): void
     {
-        $expectedRequestData = (new SignedCommandCollection($this->signedCommand))->toPayload();
+        $expectedRequestData = SignedCommandCollectionMapper::toArray(new SignedCommandCollection($this->signedCommand));
 
         $requestKeyString = 'y3aWL72-3wAy7vL9wcegGXnstH0lHi-q-cfxkhD5JCw';
 
diff --git a/tests/Unit/Crypto/CommandSignerTest.php b/tests/Unit/Crypto/CommandSignerTest.php
new file mode 100644
index 0000000..fc11bef
--- /dev/null
+++ b/tests/Unit/Crypto/CommandSignerTest.php
@@ -0,0 +1,36 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\Crypto;
+
+use Kadena\Crypto\CommandSigner;
+use Kadena\Crypto\Hash;
+use Kadena\Crypto\KeyFactory;
+use Kadena\Crypto\MessageSigner;
+use Kadena\DataMappers\CommandMapper;
+use Kadena\Pact\CommandFactory;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Signer\KeyPairCollection;
+use ParagonIE\ConstantTime\Base64UrlSafe;
+use PHPUnit\Framework\TestCase;
+
+final class CommandSignerTest extends TestCase
+{
+    /** @test */
+    public function it_should_sign_a_command_with_a_key_pair_and_return_a_signature_object(): void
+    {
+        $keyPair = KeyFactory::generate();
+
+        $command = (new CommandFactory())->withExecutePayload(new ExecutePayload(
+            code: '(+ 2 2)'
+        ))->make();
+
+        $signed = CommandSigner::sign($command, new KeyPairCollection($keyPair));
+
+        $expectedHash = Base64UrlSafe::encodeUnpadded(Hash::generic(CommandMapper::toString($command)));
+
+        $this->assertInstanceOf(SignedCommand::class, $signed);
+        $this->assertSame($expectedHash, $signed->hash);
+        $this->assertTrue(MessageSigner::verifySignature(Hash::generic(CommandMapper::toString($command)), $signed->signatures->first()->signature, $keyPair->publicKey->key));
+    }
+}
diff --git a/tests/Unit/Crypto/KeyFactoryTest.php b/tests/Unit/Crypto/KeyFactoryTest.php
new file mode 100644
index 0000000..a7af8fd
--- /dev/null
+++ b/tests/Unit/Crypto/KeyFactoryTest.php
@@ -0,0 +1,22 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\Crypto;
+
+use Kadena\Crypto\KeyFactory;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\PublicKey;
+use Kadena\ValueObjects\Signer\SecretKey;
+use PHPUnit\Framework\TestCase;
+
+final class KeyFactoryTest extends TestCase
+{
+    /** @test */
+    public function it_should_generate_a_key_pair(): void
+    {
+        $keyPair = KeyFactory::generate();
+
+        $this->assertInstanceOf(KeyPair::class, $keyPair);
+        $this->assertInstanceOf(PublicKey::class, $keyPair->publicKey);
+        $this->assertInstanceOf(SecretKey::class, $keyPair->secretKey);
+    }
+}
diff --git a/tests/Unit/Crypto/KeyPairCollectionTest.php b/tests/Unit/Crypto/KeyPairCollectionTest.php
deleted file mode 100644
index f58567e..0000000
--- a/tests/Unit/Crypto/KeyPairCollectionTest.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Crypto;
-
-use Kadena\Crypto\KeyPair;
-use Kadena\Crypto\KeyPairCollection;
-use PHPUnit\Framework\TestCase;
-
-final class KeyPairCollectionTest extends TestCase
-{
-    /** @test */
-    public function it_should_cast_to_an_array(): void
-    {
-        $keyPair1 = KeyPair::generate();
-        $keyPair2 = KeyPair::generate();
-        $keyPairCollection = new KeyPairCollection($keyPair1, $keyPair2);
-
-        $this->assertEquals([$keyPair1, $keyPair2], $keyPairCollection->toArray());
-    }
-}
diff --git a/tests/Unit/Crypto/KeyPairTest.php b/tests/Unit/Crypto/KeyPairTest.php
deleted file mode 100644
index 3460965..0000000
--- a/tests/Unit/Crypto/KeyPairTest.php
+++ /dev/null
@@ -1,21 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Crypto;
-
-use Kadena\Crypto\KeyPair;
-use ParagonIE\Halite\Asymmetric\SignaturePublicKey;
-use ParagonIE\Halite\Asymmetric\SignatureSecretKey;
-use PHPUnit\Framework\TestCase;
-
-final class KeyPairTest extends TestCase
-{
-    /** @test */
-    public function it_should_generate_a_key_pair(): void
-    {
-        $keyPair = KeyPair::generate();
-
-        $this->assertInstanceOf(KeyPair::class, $keyPair);
-        $this->assertInstanceOf(SignaturePublicKey::class, $keyPair->publicKey);
-        $this->assertInstanceOf(SignatureSecretKey::class, $keyPair->secretKey);
-    }
-}
diff --git a/tests/Unit/Crypto/MessageSignerTest.php b/tests/Unit/Crypto/MessageSignerTest.php
new file mode 100644
index 0000000..61e85ac
--- /dev/null
+++ b/tests/Unit/Crypto/MessageSignerTest.php
@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\Crypto;
+
+use Kadena\Crypto\Hash;
+use Kadena\Crypto\KeyFactory;
+use Kadena\Crypto\MessageSigner;
+use Kadena\ValueObjects\Signer\Signature;
+use ParagonIE\ConstantTime\Base64UrlSafe;
+use PHPUnit\Framework\TestCase;
+
+final class MessageSignerTest extends TestCase
+{
+    /** @test */
+    public function it_should_sign_a_message_with_a_key_pair_and_return_a_signed_message_object(): void
+    {
+        $message = 'test message';
+        $keyPair = KeyFactory::generate();
+        $signature = MessageSigner::sign($message, $keyPair);
+
+        $expectedHash = Base64UrlSafe::encodeUnpadded(Hash::generic($message));
+
+        $this->assertInstanceOf(Signature::class, $signature);
+        $this->assertSame($expectedHash, $signature->hash);
+        $this->assertTrue(MessageSigner::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey->key));
+    }
+
+    /** @test */
+    public function it_should_sign_a_hash_with_a_key_pair_and_return_a_signed_message_object(): void
+    {
+        $message = 'test message';
+        $keyPair = KeyFactory::generate();
+        $hash = Hash::generic($message);
+        $signature = MessageSigner::signHash($hash, $keyPair);
+
+        $this->assertInstanceOf(Signature::class, $signature);
+        $this->assertSame(Base64UrlSafe::encodeUnpadded($hash), $signature->hash);
+        $this->assertTrue(MessageSigner::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey->key));
+    }
+
+    /** @test */
+    public function it_should_verify_a_signature_with_a_public_key_and_message(): void
+    {
+        $keyPair = KeyFactory::generate();
+        $message = 'test message';
+        $signature = MessageSigner::sign($message, $keyPair);
+
+        $this->assertTrue(MessageSigner::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey->key));
+    }
+}
diff --git a/tests/Unit/Crypto/SignatureCollectionTest.php b/tests/Unit/Crypto/SignatureCollectionTest.php
deleted file mode 100644
index 49a937d..0000000
--- a/tests/Unit/Crypto/SignatureCollectionTest.php
+++ /dev/null
@@ -1,45 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Crypto;
-
-use Kadena\Crypto\Signature;
-use Kadena\Crypto\SignatureCollection;
-use PHPUnit\Framework\TestCase;
-
-final class SignatureCollectionTest extends TestCase
-{
-    /** @test */
-    public function it_should_return_the_first_signature(): void
-    {
-        $signature1 = new Signature('hash', 'sig1');
-        $signature2 = new Signature('hash', 'sig2');
-        $signatureCollection = new SignatureCollection($signature1, $signature2);
-
-        $this->assertSame($signature1, $signatureCollection->first());
-    }
-
-    /** @test */
-    public function it_should_return_all_signatures(): void
-    {
-        $signature1 = new Signature('hash', 'sig1');
-        $signature2 = new Signature('hash', 'sig2');
-        $signatureCollection = new SignatureCollection($signature1, $signature2);
-
-        $this->assertEquals([$signature1, $signature2], $signatureCollection->toArray());
-    }
-
-    /** @test */
-    public function it_should_create_a_new_signature_collection_from_an_array(): void
-    {
-        $signatures = [
-            ['sig' => 'sig1'],
-            ['sig' => 'sig2']
-        ];
-
-        $signatureCollection = SignatureCollection::fromArray($signatures, 'hash');
-
-        $this->assertInstanceOf(SignatureCollection::class, $signatureCollection);
-        $this->assertSame('hash', $signatureCollection->first()->hash);
-        $this->assertSame('sig1', $signatureCollection->first()->signature);
-    }
-}
diff --git a/tests/Unit/Crypto/SignerTest.php b/tests/Unit/Crypto/SignerTest.php
deleted file mode 100644
index 909f694..0000000
--- a/tests/Unit/Crypto/SignerTest.php
+++ /dev/null
@@ -1,87 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Crypto;
-
-use Carbon\Carbon;
-use Kadena\Crypto\Hash;
-use Kadena\Crypto\KeyPair;
-use Kadena\Crypto\Signature;
-use Kadena\Crypto\Signer;
-use Kadena\Pact\Command;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Meta;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use ParagonIE\ConstantTime\Base64UrlSafe;
-use PHPUnit\Framework\TestCase;
-
-final class SignerTest extends TestCase
-{
-    /** @test */
-    public function it_should_sign_a_message_with_a_key_pair_and_return_a_signed_message_object(): void
-    {
-        $message = 'test message';
-        $keyPair = KeyPair::generate();
-        $signature = Signer::sign($message, $keyPair);
-
-        $expectedHash = Base64UrlSafe::encodeUnpadded(Hash::generic($message));
-
-        $this->assertInstanceOf(Signature::class, $signature);
-        $this->assertSame($expectedHash, $signature->hash);
-        $this->assertTrue(Signer::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey));
-    }
-
-    /** @test */
-    public function it_should_sign_a_hash_with_a_key_pair_and_return_a_signed_message_object(): void
-    {
-        $message = 'test message';
-        $keyPair = KeyPair::generate();
-        $hash = Hash::generic($message);
-        $signature = Signer::signHash($hash, $keyPair);
-
-        $this->assertInstanceOf(Signature::class, $signature);
-        $this->assertSame(Base64UrlSafe::encodeUnpadded($hash), $signature->hash);
-        $this->assertTrue(Signer::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey));
-    }
-
-    /** @test */
-    public function it_should_verify_a_signature_with_a_public_key_and_message(): void
-    {
-        $keyPair = KeyPair::generate();
-        $message = 'test message';
-        $signature = Signer::sign($message, $keyPair);
-
-        $this->assertTrue(Signer::verifySignature(Hash::generic($message), $signature->signature, $keyPair->publicKey));
-    }
-
-    /** @test */
-    public function it_should_sign_a_command_with_a_key_pair_and_return_a_signature_object(): void
-    {
-        $keyPair = KeyPair::generate();
-
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $signature = Signer::signCommand($command, $keyPair);
-
-        $expectedHash = Base64UrlSafe::encodeUnpadded(Hash::generic($command->toString()));
-
-        $this->assertInstanceOf(Signature::class, $signature);
-        $this->assertSame($expectedHash, $signature->hash);
-        $this->assertTrue(Signer::verifySignature(Hash::generic($command->toString()), $signature->signature, $keyPair->publicKey));
-    }
-}
diff --git a/tests/Unit/DataMappers/CommandMapperTest.php b/tests/Unit/DataMappers/CommandMapperTest.php
new file mode 100644
index 0000000..a2a212a
--- /dev/null
+++ b/tests/Unit/DataMappers/CommandMapperTest.php
@@ -0,0 +1,111 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\DataMappers;
+
+use Carbon\Carbon;
+use Kadena\Crypto\KeyFactory;
+use Kadena\DataMappers\CommandMapper;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+use PHPUnit\Framework\TestCase;
+
+final class CommandMapperTest extends TestCase
+{
+    private Command $command;
+    private array $commandArray;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $keyPair = KeyFactory::generate();
+
+        $this->command = new Command(
+            meta: new Metadata(
+                creationTime: Carbon::createFromTimestamp(0),
+                ttl: 0,
+                gasLimit: 0,
+                chainId: '',
+                gasPrice: 0,
+                sender: ''
+            ),
+            payload: new Payload(
+                payloadType: PayloadType::EXECUTE,
+                executePayload: new ExecutePayload(
+                    code: '(+ 2 2)'
+                )
+            ),
+            networkId: 'testnet0',
+            nonce: 'test',
+            signers: new SignerCollection(new Signer(
+                publicKey: $keyPair->publicKey,
+                capabilities: new CapabilityCollection(
+                    new Capability(
+                        name: 'cap.example',
+                        arguments: []
+                    )
+                )
+            ))
+        );
+
+        $this->commandArray = [
+            'networkId' => 'testnet0',
+            'payload' => [
+                'exec' => [
+                    'data' => [],
+                    'code' => '(+ 2 2)'
+                ]
+            ],
+            'meta' => [
+                'creationTime' => 0,
+                'ttl' => 0,
+                'gasLimit' => 0,
+                'chainId' => '',
+                'gasPrice' => 0,
+                'sender' => ''
+            ],
+            'nonce' => 'test',
+            'signers' => [
+                [
+                    'pubKey' => $keyPair->publicKey->toString(),
+                    'clist' => [
+                        [
+                            'name' => 'cap.example',
+                            'args' => []
+                        ]
+                    ]
+                ]
+            ],
+        ];
+    }
+    /** @test */
+    public function it_should_be_able_to_map_a_command_to_an_array(): void
+    {
+        $actual = CommandMapper::toArray($this->command);
+
+        $this->assertEquals($this->commandArray, $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_command_to_a_string(): void
+    {
+        $actual = CommandMapper::toString($this->command);
+
+        $this->assertEquals(json_encode($this->commandArray, JSON_THROW_ON_ERROR), $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_string_to_a_command(): void
+    {
+        $actual = CommandMapper::fromString(json_encode($this->commandArray, JSON_THROW_ON_ERROR));
+
+        $this->assertEquals($this->command, $actual);
+    }
+}
diff --git a/tests/Unit/DataMappers/SignedCommandCollectionMapperTest.php b/tests/Unit/DataMappers/SignedCommandCollectionMapperTest.php
new file mode 100644
index 0000000..ed86bec
--- /dev/null
+++ b/tests/Unit/DataMappers/SignedCommandCollectionMapperTest.php
@@ -0,0 +1,125 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\DataMappers;
+
+use Carbon\Carbon;
+use Kadena\Crypto\KeyFactory;
+use Kadena\DataMappers\SignedCommandCollectionMapper;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Command\SignedCommandCollection;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\Signature;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+use PHPUnit\Framework\TestCase;
+
+final class SignedCommandCollectionMapperTest extends TestCase
+{
+    private SignedCommand $signedCommand;
+    private array $signedCommandArray;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $keyPair = KeyFactory::generate();
+
+        $command = new Command(
+            meta: new Metadata(
+                creationTime: Carbon::createFromTimestamp(0),
+                ttl: 0,
+                gasLimit: 0,
+                chainId: '',
+                gasPrice: 0,
+                sender: ''
+            ),
+            payload: new Payload(
+                payloadType: PayloadType::EXECUTE,
+                executePayload: new ExecutePayload(
+                    code: '(+ 2 2)'
+                )
+            ),
+            networkId: 'testnet0',
+            nonce: 'test',
+            signers: new SignerCollection(new Signer(
+                publicKey: $keyPair->publicKey,
+                capabilities: new CapabilityCollection(
+                    new Capability(
+                        name: 'cap.example',
+                        arguments: []
+                    )
+                )
+            ))
+        );
+
+        $commandArray = [
+            'networkId' => 'testnet0',
+            'payload' => [
+                'exec' => [
+                    'data' => [],
+                    'code' => '(+ 2 2)'
+                ]
+            ],
+            'meta' => [
+                'creationTime' => 0,
+                'ttl' => 0,
+                'gasLimit' => 0,
+                'chainId' => '',
+                'gasPrice' => 0,
+                'sender' => ''
+            ],
+            'nonce' => 'test',
+            'signers' => [
+                [
+                    'pubKey' => $keyPair->publicKey->toString(),
+                    'clist' => [
+                        [
+                            'name' => 'cap.example',
+                            'args' => []
+                        ]
+                    ]
+                ]
+            ],
+        ];
+
+        $this->signedCommand = new SignedCommand(
+            hash: 'test-hash',
+            signatures: new SignatureCollection(new Signature(
+                hash: 'test-hash',
+                signature: 'test-signature'
+            )),
+            command: $command
+        );
+
+        $this->signedCommandArray = [
+            'cmd' => json_encode($commandArray, JSON_THROW_ON_ERROR),
+            'hash' => 'test-hash',
+            'sigs' => [
+                ['sig' => 'test-signature']
+            ],
+        ];
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_signed_command_collection_to_an_array(): void
+    {
+        $actual = SignedCommandCollectionMapper::toArray(new SignedCommandCollection($this->signedCommand));
+
+        $this->assertEquals(['cmds' => [$this->signedCommandArray]], $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_signed_command_collection_to_a_string(): void
+    {
+        $actual = SignedCommandCollectionMapper::toString(new SignedCommandCollection($this->signedCommand));
+
+        $this->assertEquals(json_encode(['cmds' => [$this->signedCommandArray]], JSON_THROW_ON_ERROR), $actual);
+    }
+}
diff --git a/tests/Unit/DataMappers/SignedCommandMapperTest.php b/tests/Unit/DataMappers/SignedCommandMapperTest.php
new file mode 100644
index 0000000..76a80d8
--- /dev/null
+++ b/tests/Unit/DataMappers/SignedCommandMapperTest.php
@@ -0,0 +1,132 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\DataMappers;
+
+use Carbon\Carbon;
+use Kadena\Crypto\KeyFactory;
+use Kadena\DataMappers\SignedCommandMapper;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Metadata;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Command\SignedCommand;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\Signature;
+use Kadena\ValueObjects\Signer\SignatureCollection;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+use PHPUnit\Framework\TestCase;
+
+final class SignedCommandMapperTest extends TestCase
+{
+    private SignedCommand $signedCommand;
+    private array $signedCommandArray;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        $keyPair = KeyFactory::generate();
+
+        $command = new Command(
+            meta: new Metadata(
+                creationTime: Carbon::createFromTimestamp(0),
+                ttl: 0,
+                gasLimit: 0,
+                chainId: '',
+                gasPrice: 0,
+                sender: ''
+            ),
+            payload: new Payload(
+                payloadType: PayloadType::EXECUTE,
+                executePayload: new ExecutePayload(
+                    code: '(+ 2 2)'
+                )
+            ),
+            networkId: 'testnet0',
+            nonce: 'test',
+            signers: new SignerCollection(new Signer(
+                publicKey: $keyPair->publicKey,
+                capabilities: new CapabilityCollection(
+                    new Capability(
+                        name: 'cap.example',
+                        arguments: []
+                    )
+                )
+            ))
+        );
+
+        $commandArray = [
+            'networkId' => 'testnet0',
+            'payload' => [
+                'exec' => [
+                    'data' => [],
+                    'code' => '(+ 2 2)'
+                ]
+            ],
+            'meta' => [
+                'creationTime' => 0,
+                'ttl' => 0,
+                'gasLimit' => 0,
+                'chainId' => '',
+                'gasPrice' => 0,
+                'sender' => ''
+            ],
+            'nonce' => 'test',
+            'signers' => [
+                [
+                    'pubKey' => $keyPair->publicKey->toString(),
+                    'clist' => [
+                        [
+                            'name' => 'cap.example',
+                            'args' => []
+                        ]
+                    ]
+                ]
+            ],
+        ];
+
+        $this->signedCommand = new SignedCommand(
+            hash: 'test-hash',
+            signatures: new SignatureCollection(new Signature(
+                hash: 'test-hash',
+                signature: 'test-signature'
+            )),
+            command: $command
+        );
+
+        $this->signedCommandArray = [
+            'cmd' => json_encode($commandArray, JSON_THROW_ON_ERROR),
+            'hash' => 'test-hash',
+            'sigs' => [
+                ['sig' => 'test-signature']
+            ],
+        ];
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_signed_command_to_an_array(): void
+    {
+        $actual = SignedCommandMapper::toArray($this->signedCommand);
+
+        $this->assertEquals($this->signedCommandArray, $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_signed_command_to_a_string(): void
+    {
+        $actual = SignedCommandMapper::toString($this->signedCommand);
+
+        $this->assertEquals(json_encode($this->signedCommandArray, JSON_THROW_ON_ERROR), $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_map_a_string_to_a_signed_command(): void
+    {
+        $actual = SignedCommandMapper::fromString(json_encode($this->signedCommandArray, JSON_THROW_ON_ERROR));
+
+        $this->assertEquals($this->signedCommand, $actual);
+    }
+}
diff --git a/tests/Unit/Pact/CommandFactoryTest.php b/tests/Unit/Pact/CommandFactoryTest.php
new file mode 100644
index 0000000..3ad8d19
--- /dev/null
+++ b/tests/Unit/Pact/CommandFactoryTest.php
@@ -0,0 +1,126 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\Pact;
+
+use Carbon\Carbon;
+use Kadena\Crypto\KeyFactory;
+use Kadena\Pact\CommandFactory;
+use Kadena\Pact\MetadataFactory;
+use Kadena\ValueObjects\Command\Command;
+use Kadena\ValueObjects\Command\Payload\ContinuePayload;
+use Kadena\ValueObjects\Command\Payload\ExecutePayload;
+use Kadena\ValueObjects\Command\Payload\Payload;
+use Kadena\ValueObjects\Command\Payload\PayloadType;
+use Kadena\ValueObjects\Signer\Capability;
+use Kadena\ValueObjects\Signer\CapabilityCollection;
+use Kadena\ValueObjects\Signer\KeyPair;
+use Kadena\ValueObjects\Signer\Signer;
+use Kadena\ValueObjects\Signer\SignerCollection;
+use PHPUnit\Framework\TestCase;
+
+final class CommandFactoryTest extends TestCase
+{
+    private KeyPair $keyPair;
+
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        Carbon::setTestNow('2021-11-26 12:30:00');
+
+        $this->keyPair = KeyFactory::generate();
+    }
+
+    /** @test */
+    public function it_should_be_able_to_construct_a_command_with_default_options_from_a_execute_payload(): void
+    {
+        $factory = new CommandFactory();
+        $payload = new ExecutePayload(
+            code: '(+ 2 2)'
+        );
+
+        $expected = new Command(
+            meta: (new MetadataFactory())->make(),
+            payload: new Payload(
+                payloadType: PayloadType::EXECUTE,
+                executePayload: $payload
+            ),
+            networkId: '0',
+            nonce: Carbon::now()->toISOString(),
+            signers: new SignerCollection(),
+        );
+
+        $actual = $factory->withExecutePayload($payload)->make();
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_construct_a_command_with_default_options_from_a_continue_payload(): void
+    {
+        $factory = new CommandFactory();
+        $payload = new ContinuePayload(
+            pactId: 'pact-id',
+            rollback: false,
+            step: 0,
+            proof: 'proof',
+            data: []
+        );
+
+        $expected = new Command(
+            meta: (new MetadataFactory())->make(),
+            payload: new Payload(
+                payloadType: PayloadType::CONTINUE,
+                continuePayload: $payload
+            ),
+            networkId: '0',
+            nonce: Carbon::now()->toISOString(),
+            signers: new SignerCollection(),
+        );
+
+        $actual = $factory->withContinuePayload($payload)->make();
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_construct_a_command_with_defined_options(): void
+    {
+        $factory = new CommandFactory();
+        $payload = new ExecutePayload(
+            code: '(+ 2 2)'
+        );
+        $signers = new SignerCollection(
+            new Signer(
+                publicKey: $this->keyPair->publicKey,
+                capabilities: new CapabilityCollection(
+                    new Capability(
+                        name: 'test.cap',
+                        arguments: []
+                    )
+                )
+            )
+        );
+        $meta = (new MetadataFactory())->make();
+
+        $expected = new Command(
+            meta: $meta,
+            payload: new Payload(
+                payloadType: PayloadType::EXECUTE,
+                executePayload: $payload
+            ),
+            networkId: 'network-0',
+            nonce: 'test-nonce',
+            signers: $signers,
+        );
+
+        $actual = $factory->withExecutePayload($payload)
+            ->withNonce('test-nonce')
+            ->withSigners($signers)
+            ->withMetadata($meta)
+            ->withNetworkId('network-0')
+            ->make();
+
+        $this->assertEquals($expected, $actual);
+    }
+}
diff --git a/tests/Unit/Pact/CommandTest.php b/tests/Unit/Pact/CommandTest.php
deleted file mode 100644
index 02ceaa0..0000000
--- a/tests/Unit/Pact/CommandTest.php
+++ /dev/null
@@ -1,284 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Carbon\Carbon;
-use Kadena\Crypto\Hash;
-use Kadena\Crypto\KeyPair;
-use Kadena\Crypto\KeyPairCollection;
-use Kadena\Crypto\Signer;
-use Kadena\Pact\Command;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Meta;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use Kadena\Pact\SignedCommand;
-use ParagonIE\ConstantTime\Base64UrlSafe;
-use ParagonIE\ConstantTime\Hex;
-use PHPUnit\Framework\TestCase;
-
-final class CommandTest extends TestCase
-{
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        Carbon::setTestNow('2021-11-26 12:30:00');
-    }
-
-    /** @test */
-    public function it_should_set_nonce_to_current_time_if_not_defined(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $this->assertEquals(Carbon::now()->toISOString(), $command->nonce);
-    }
-
-    /** @test */
-    public function it_should_cast_to_array(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $expected = [
-            'signers' => [],
-            'networkId' => null,
-            'payload' => [
-                'exec' => [
-                    'data' => [],
-                    'code' => '(+ 2 2)'
-                ]
-            ],
-            'meta' => [
-                'creationTime' => 0,
-                'ttl' => 0,
-                'gasLimit' => 0,
-                'chainId' => '',
-                'gasPrice' => 0,
-                'sender' => ''
-            ],
-            'nonce' => '2021-11-26T12:30:00.000000Z'
-        ];
-
-        $this->assertEquals($expected, $command->toArray());
-    }
-
-    /** @test */
-    public function it_should_cast_to_string(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $expected = json_encode([
-            'signers' => [],
-            'networkId' => null,
-            'payload' => [
-                'exec' => [
-                    'data' => [],
-                    'code' => '(+ 2 2)'
-                ]
-            ],
-            'meta' => [
-                'creationTime' => 0,
-                'ttl' => 0,
-                'gasLimit' => 0,
-                'chainId' => '',
-                'gasPrice' => 0,
-                'sender' => ''
-            ],
-            'nonce' => '2021-11-26T12:30:00.000000Z'
-        ], JSON_THROW_ON_ERROR);
-
-        $this->assertEquals($expected, $command->toString());
-    }
-
-    /** @test */
-    public function it_should_construct_from_string(): void
-    {
-        $expected = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $jsonCommand = json_encode([
-            'signers' => [],
-            'networkId' => null,
-            'payload' => [
-                'exec' => [
-                    'data' => [],
-                    'code' => '(+ 2 2)'
-                ]
-            ],
-            'meta' => [
-                'creationTime' => 0,
-                'ttl' => 0,
-                'gasLimit' => 0,
-                'chainId' => '',
-                'gasPrice' => 0,
-                'sender' => ''
-            ],
-            'nonce' => '2021-11-26T12:30:00.000000Z'
-        ], JSON_THROW_ON_ERROR);
-
-        $this->assertEquals($expected, Command::fromString($jsonCommand));
-    }
-
-    /** @test */
-    public function it_should_be_able_to_set_signers(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $expectedWithoutSigners = [
-            'signers' => [],
-            'networkId' => null,
-            'payload' => [
-                'exec' => [
-                    'data' => [],
-                    'code' => '(+ 2 2)'
-                ]
-            ],
-            'meta' => [
-                'creationTime' => 0,
-                'ttl' => 0,
-                'gasLimit' => 0,
-                'chainId' => '',
-                'gasPrice' => 0,
-                'sender' => ''
-            ],
-            'nonce' => '2021-11-26T12:30:00.000000Z'
-        ];
-
-        $this->assertEquals($expectedWithoutSigners, $command->toArray());
-
-        $expectedWithSigners = [
-            'signers' => [
-                ['pubKey' => 'public-key1'],
-                ['pubKey' => 'public-key2'],
-            ],
-            'networkId' => null,
-            'payload' => [
-                'exec' => [
-                    'data' => [],
-                    'code' => '(+ 2 2)'
-                ]
-            ],
-            'meta' => [
-                'creationTime' => 0,
-                'ttl' => 0,
-                'gasLimit' => 0,
-                'chainId' => '',
-                'gasPrice' => 0,
-                'sender' => ''
-            ],
-            'nonce' => '2021-11-26T12:30:00.000000Z'
-        ];
-
-        $command->setSigners(['public-key1', 'public-key2']);
-
-        $this->assertEquals($expectedWithSigners, $command->toArray());
-    }
-
-    /** @test */
-    public function it_should_return_a_signed_command_object_when_using_get_signed_command(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $keyPair = KeyPair::generate();
-
-        $command->setSigners([Hex::encode($keyPair->publicKey->getRawKeyMaterial())]);
-
-        $message = $command->toString();
-        $expectedHash = Base64UrlSafe::encodeUnpadded(Hash::generic($message));
-
-        $signedCommand = $command->getSignedCommand(new KeyPairCollection($keyPair));
-
-        $this->assertInstanceOf(SignedCommand::class, $signedCommand);
-        $this->assertSame($expectedHash, $signedCommand->hash);
-        $this->assertTrue(Signer::verifySignature(Hash::generic($message), $signedCommand->signatures->first()->signature, $keyPair->publicKey));
-    }
-}
diff --git a/tests/Unit/Pact/ContinuePayloadTest.php b/tests/Unit/Pact/ContinuePayloadTest.php
deleted file mode 100644
index e4d4405..0000000
--- a/tests/Unit/Pact/ContinuePayloadTest.php
+++ /dev/null
@@ -1,31 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Kadena\Pact\ContinuePayload;
-use PHPUnit\Framework\TestCase;
-
-final class ContinuePayloadTest extends TestCase
-{
-    /** @test */
-    public function it_should_return_the_correct_array_representation_of_the_payload(): void
-    {
-        $pactId = 'pact-id';
-        $rollback = false;
-        $step = 0;
-        $proof = 'proof';
-        $data = ['key' => 'value'];
-
-        $continuePayload = new ContinuePayload($pactId, $rollback, $step, $proof, $data);
-
-        $expectedArray = [
-            'proof' => $proof,
-            'pactId' => $pactId,
-            'rollback' => $rollback,
-            'step' => $step,
-            'data' => $data
-        ];
-
-        $this->assertSame($expectedArray, $continuePayload->toArray());
-    }
-}
diff --git a/tests/Unit/Pact/ExecutePayloadTest.php b/tests/Unit/Pact/ExecutePayloadTest.php
deleted file mode 100644
index cf881ba..0000000
--- a/tests/Unit/Pact/ExecutePayloadTest.php
+++ /dev/null
@@ -1,24 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Kadena\Pact\ExecutePayload;
-use PHPUnit\Framework\TestCase;
-
-final class ExecutePayloadTest extends TestCase
-{
-    /** @test */
-    public function it_should_return_the_correct_array_representation_of_the_payload(): void
-    {
-        $code = 'test code';
-        $data = ['key' => 'value'];
-
-        $executePayload = new ExecutePayload($code, $data);
-        $expectedArray = [
-            'data' => $data,
-            'code' => $code,
-        ];
-
-        $this->assertSame($expectedArray, $executePayload->toArray());
-    }
-}
diff --git a/tests/Unit/Pact/MetaTest.php b/tests/Unit/Pact/MetaTest.php
deleted file mode 100644
index 7fd5b61..0000000
--- a/tests/Unit/Pact/MetaTest.php
+++ /dev/null
@@ -1,83 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Carbon\Carbon;
-use Kadena\Pact\Meta;
-use PHPUnit\Framework\TestCase;
-
-final class MetaTest extends TestCase
-{
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        Carbon::setTestNow('2021-11-26 12:30:00');
-    }
-
-    /** @test */
-    public function it_should_return_the_correct_array_representation_of_the_meta_object(): void
-    {
-        $creationTime = Carbon::now();
-        $ttl = 300;
-        $gasLimit = 50;
-        $chainId = 'test-chain-id';
-        $gasPrice = 1.25;
-        $sender = 'test-sender';
-
-        $meta = new Meta($creationTime, $ttl, $gasLimit, $chainId, $gasPrice, $sender);
-        $expectedArray = [
-            'creationTime' => $creationTime->getTimestamp(),
-            'ttl' => $ttl,
-            'gasLimit' => $gasLimit,
-            'chainId' => $chainId,
-            'gasPrice' => $gasPrice,
-            'sender' => $sender
-        ];
-
-        $this->assertSame($expectedArray, $meta->toArray());
-    }
-
-    /** @test */
-    public function it_should_be_able_to_be_constructed_from_an_options_array(): void
-    {
-        $creationTime = Carbon::now();
-        $ttl = 300;
-        $gasLimit = 50;
-        $chainId = 'test-chain-id';
-        $gasPrice = 1.25;
-        $sender = 'test-sender';
-
-        $expected = new Meta($creationTime, $ttl, $gasLimit, $chainId, $gasPrice, $sender);
-
-        $options = [
-            'creationTime' => $creationTime->getTimestamp(),
-            'ttl' => $ttl,
-            'gasLimit' => $gasLimit,
-            'chainId' => $chainId,
-            'gasPrice' => $gasPrice,
-            'sender' => $sender
-        ];
-
-        $actual = Meta::create($options);
-
-        $this->assertEquals($expected, $actual);
-    }
-
-    /** @test */
-    public function it_should_be_able_to_be_constructed_using_the_create_method_with_default_options(): void
-    {
-        $creationTime = Carbon::now();
-        $ttl = 7200;
-        $gasLimit = 10000;
-        $chainId = '0';
-        $gasPrice = 1e-8;
-        $sender = '';
-
-        $expected = new Meta($creationTime, $ttl, $gasLimit, $chainId, $gasPrice, $sender);
-
-        $actual = Meta::create();
-
-        $this->assertEquals($expected, $actual);
-    }
-}
diff --git a/tests/Unit/Pact/MetadataFactoryTest.php b/tests/Unit/Pact/MetadataFactoryTest.php
new file mode 100644
index 0000000..1fcdee6
--- /dev/null
+++ b/tests/Unit/Pact/MetadataFactoryTest.php
@@ -0,0 +1,61 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\Pact;
+
+use Carbon\Carbon;
+use Kadena\Pact\MetadataFactory;
+use Kadena\ValueObjects\Command\Metadata;
+use PHPUnit\Framework\TestCase;
+
+final class MetadataFactoryTest extends TestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        Carbon::setTestNow('2021-11-26 12:30:00');
+    }
+
+    /** @test */
+    public function it_should_be_able_to_construct_a_metadata_object_with_default_values(): void
+    {
+        $expected = new Metadata(
+            creationTime: Carbon::now(),
+            ttl: 7200,
+            gasLimit: 10000,
+            chainId: '0',
+            gasPrice: 1e-8,
+            sender: ''
+        );
+
+        $actual = (new MetadataFactory())->make();
+
+        $this->assertEquals($expected, $actual);
+    }
+
+    /** @test */
+    public function it_should_be_able_to_construct_a_metadata_object_with_supplied_options(): void
+    {
+        $expected = new Metadata(
+            creationTime: Carbon::now()->subDay(),
+            ttl: 3600,
+            gasLimit: 15000,
+            chainId: '2',
+            gasPrice: 1e-7,
+            sender: 'sender'
+        );
+
+        $actual = (new MetadataFactory())
+            ->withOptions([
+                'creationTime' => Carbon::now()->subDay()->getTimestamp(),
+                'ttl' => 3600,
+                'gasLimit' => 15000,
+                'chainId' => '2',
+                'gasPrice' => 1e-7,
+                'sender' => 'sender',
+            ])
+            ->make();
+
+        $this->assertEquals($expected, $actual);
+    }
+}
diff --git a/tests/Unit/Pact/PayloadTest.php b/tests/Unit/Pact/PayloadTest.php
deleted file mode 100644
index 75e39d3..0000000
--- a/tests/Unit/Pact/PayloadTest.php
+++ /dev/null
@@ -1,60 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use InvalidArgumentException;
-use Kadena\Pact\ContinuePayload;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use PHPUnit\Framework\TestCase;
-
-final class PayloadTest extends TestCase
-{
-    /** @test */
-    public function it_should_validate_continue_payload(): void
-    {
-        $this->expectException(InvalidArgumentException::class);
-
-        new Payload(PayloadType::CONTINUE, null, new ExecutePayload('test', []));
-    }
-
-    /** @test */
-    public function it_should_validate_execute_payload(): void
-    {
-        $this->expectException(InvalidArgumentException::class);
-
-        new Payload(PayloadType::EXECUTE, new ContinuePayload('test', true, 1), null);
-    }
-
-    /** @test */
-    public function it_should_create_and_return_valid_execute_payload(): void
-    {
-        $payload = new Payload(
-            payloadType: PayloadType::EXECUTE,
-            executePayload: new ExecutePayload(
-                code: 'test',
-                data: ['key' => 'value']
-            )
-        );
-
-        $this->assertSame([PayloadType::EXECUTE->value => ['data' => ['key' => 'value'], 'code' => 'test']], $payload->toArray());
-    }
-
-    /** @test */
-    public function it_should_create_and_return_valid_continue_payload(): void
-    {
-        $payload = new Payload(
-            payloadType: PayloadType::CONTINUE,
-            continuePayload: new ContinuePayload(
-                pactId: 'test',
-                rollback: true,
-                step: 1,
-                proof: 'proof',
-                data: ['key' => 'value']
-            )
-        );
-
-        $this->assertSame([PayloadType::CONTINUE->value => ['proof' => 'proof', 'pactId' => 'test', 'rollback' => true, 'step' => 1, 'data' => ['key' => 'value']]], $payload->toArray());
-    }
-}
diff --git a/tests/Unit/Pact/RequestKeyCollectionTest.php b/tests/Unit/Pact/RequestKeyCollectionTest.php
deleted file mode 100644
index a660754..0000000
--- a/tests/Unit/Pact/RequestKeyCollectionTest.php
+++ /dev/null
@@ -1,43 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Kadena\Pact\RequestKey;
-use Kadena\Pact\RequestKeyCollection;
-use PHPUnit\Framework\TestCase;
-
-final class RequestKeyCollectionTest extends TestCase
-{
-    /** @test */
-    public function it_should_create_request_key_collection(): void
-    {
-        $requestKey1 = new RequestKey('key1');
-        $requestKey2 = new RequestKey('key2');
-
-        $requestKeyCollection = new RequestKeyCollection($requestKey1, $requestKey2);
-
-        $this->assertEquals([$requestKey1, $requestKey2], $requestKeyCollection->toArray());
-    }
-
-    /** @test */
-    public function it_should_get_first_request_key(): void
-    {
-        $requestKey1 = new RequestKey('key1');
-        $requestKey2 = new RequestKey('key2');
-
-        $requestKeyCollection = new RequestKeyCollection($requestKey1, $requestKey2);
-
-        $this->assertEquals($requestKey1, $requestKeyCollection->first());
-    }
-
-    /** @test */
-    public function it_should_convert_to_plain_array(): void
-    {
-        $requestKey1 = new RequestKey('key1');
-        $requestKey2 = new RequestKey('key2');
-
-        $requestKeyCollection = new RequestKeyCollection($requestKey1, $requestKey2);
-
-        $this->assertEquals(['key1', 'key2'], $requestKeyCollection->toPlainArray());
-    }
-}
diff --git a/tests/Unit/Pact/SignedCommandCollectionTest.php b/tests/Unit/Pact/SignedCommandCollectionTest.php
deleted file mode 100644
index 194b7c3..0000000
--- a/tests/Unit/Pact/SignedCommandCollectionTest.php
+++ /dev/null
@@ -1,151 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Carbon\Carbon;
-use Kadena\Crypto\Signature;
-use Kadena\Crypto\SignatureCollection;
-use Kadena\Pact\Command;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Meta;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use Kadena\Pact\SignedCommand;
-use Kadena\Pact\SignedCommandCollection;
-use PHPUnit\Framework\TestCase;
-
-final class SignedCommandCollectionTest extends TestCase
-{
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        Carbon::setTestNow('2021-11-26 12:30:00');
-    }
-
-    /** @test */
-    public function it_should_convert_to_an_array(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $command->setSigners(['public-key']);
-
-        $signature = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signatures = new SignatureCollection($signature);
-
-        $signedCommand = new SignedCommand('hash', $signatures, $command);
-
-        $signedCommandCollection = new SignedCommandCollection($signedCommand);
-
-        $this->assertEquals([$signedCommand], $signedCommandCollection->toArray());
-    }
-
-    /** @test */
-    public function it_should_convert_in_to_a_payload_array(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $command->setSigners(['public-key']);
-
-        $signature = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signatures = new SignatureCollection($signature);
-
-        $signedCommand = new SignedCommand('hash', $signatures, $command);
-
-        $signedCommandCollection = new SignedCommandCollection($signedCommand);
-
-        $expected = [
-            'cmds' => [
-                [
-                    'hash' => 'hash',
-                    'sigs' => [
-                        [
-                            'sig' => 'signature'
-                        ]
-                    ],
-                    'cmd' => '{"signers":[{"pubKey":"public-key"}],"networkId":null,"payload":{"exec":{"data":[],"code":"(+ 2 2)"}},"meta":{"creationTime":0,"ttl":0,"gasLimit":0,"chainId":"","gasPrice":0,"sender":""},"nonce":"2021-11-26T12:30:00.000000Z"}'
-                ]
-            ]
-        ];
-
-        $this->assertEquals($expected, $signedCommandCollection->toPayload());
-    }
-
-    /** @test */
-    public function it_should_convert_in_to_a_json_payload_string(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $command->setSigners(['public-key']);
-
-        $signature = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signatures = new SignatureCollection($signature);
-
-        $signedCommand = new SignedCommand('hash', $signatures, $command);
-
-        $signedCommandCollection = new SignedCommandCollection($signedCommand);
-
-        $expected = '{"cmds":[{"hash":"hash","sigs":[{"sig":"signature"}],"cmd":"{\"signers\":[{\"pubKey\":\"public-key\"}],\"networkId\":null,\"payload\":{\"exec\":{\"data\":[],\"code\":\"(+ 2 2)\"}},\"meta\":{\"creationTime\":0,\"ttl\":0,\"gasLimit\":0,\"chainId\":\"\",\"gasPrice\":0,\"sender\":\"\"},\"nonce\":\"2021-11-26T12:30:00.000000Z\"}"}]}';
-        $this->assertEquals($expected, $signedCommandCollection->toPayloadString());
-    }
-}
diff --git a/tests/Unit/Pact/SignedCommandTest.php b/tests/Unit/Pact/SignedCommandTest.php
deleted file mode 100644
index b0733d7..0000000
--- a/tests/Unit/Pact/SignedCommandTest.php
+++ /dev/null
@@ -1,175 +0,0 @@
-<?php declare(strict_types=1);
-
-namespace Kadena\Tests\Unit\Pact;
-
-use Carbon\Carbon;
-use InvalidArgumentException;
-use Kadena\Crypto\Signature;
-use Kadena\Crypto\SignatureCollection;
-use Kadena\Pact\Command;
-use Kadena\Pact\ExecutePayload;
-use Kadena\Pact\Meta;
-use Kadena\Pact\Payload;
-use Kadena\Pact\PayloadType;
-use Kadena\Pact\SignedCommand;
-use PHPUnit\Framework\TestCase;
-
-final class SignedCommandTest extends TestCase
-{
-    protected function setUp(): void
-    {
-        parent::setUp();
-
-        Carbon::setTestNow('2021-11-26 12:30:00');
-    }
-
-    /** @test */
-    public function it_should_create_signed_command_from_string(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $command->setSigners(['public-key']);
-
-        $signature = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signatures = new SignatureCollection($signature);
-
-        $signedCommand = new SignedCommand('hash', $signatures, $command);
-
-        $commandJson = $signedCommand->toString();
-
-        $signedCommandFromJson = SignedCommand::fromString($commandJson);
-
-        $this->assertEquals($signedCommand->command, $signedCommandFromJson->command);
-        $this->assertEquals($signedCommand->hash, $signedCommandFromJson->hash);
-    }
-
-    /** @test */
-    public function it_should_validate_signatures_when_creating(): void
-    {
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $command->setSigners(['public-key']);
-
-        $signature1 = new Signature(
-            hash: 'hash',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signature2 = new Signature(
-            hash: 'incorrect',
-            signature: 'signature',
-            publicKey: 'public-key',
-        );
-
-        $signatures = new SignatureCollection($signature1, $signature2);
-
-        $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage('Signatures for different hashes found: incorrect, expected: hash');
-
-        new SignedCommand('hash', $signatures, $command);
-    }
-
-    /** @test */
-    public function it_should_return_the_expected_array(): void
-    {
-        $signature1 = new Signature('hash1', 'signature1');
-        $signature2 = new Signature('hash1', 'signature2');
-        $signatureCollection = new SignatureCollection($signature1, $signature2);
-
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $signedCommand = new SignedCommand('hash1', $signatureCollection, $command);
-
-        $expectedArray = [
-            'hash' => 'hash1',
-            'sigs' => [
-                ['sig' => 'signature1'],
-                ['sig' => 'signature2'],
-            ],
-            'cmd' => $command->toString(),
-        ];
-
-        $this->assertSame($expectedArray, $signedCommand->toArray());
-    }
-
-    /** @test */
-    public function it_should_return_the_expected_string(): void
-    {
-        $signature1 = new Signature('hash1', 'signature1');
-        $signature2 = new Signature('hash1', 'signature2');
-        $signatureCollection = new SignatureCollection($signature1, $signature2);
-
-        $command = new Command(
-            meta: new Meta(
-                creationTime: Carbon::createFromTimestamp(0),
-                ttl: 0,
-                gasLimit: 0,
-                chainId: '',
-                gasPrice: 0,
-                sender: ''
-            ),
-            payload: new Payload(
-                payloadType: PayloadType::EXECUTE,
-                executePayload: new ExecutePayload(
-                    code: '(+ 2 2)'
-                )
-            )
-        );
-
-        $signedCommand = new SignedCommand('hash1', $signatureCollection, $command);
-
-        $expectedString = '{"hash":"hash1","sigs":[{"sig":"signature1"},{"sig":"signature2"}],"cmd":"{\"signers\":[],\"networkId\":null,\"payload\":{\"exec\":{\"data\":[],\"code\":\"(+ 2 2)\"}},\"meta\":{\"creationTime\":0,\"ttl\":0,\"gasLimit\":0,\"chainId\":\"\",\"gasPrice\":0,\"sender\":\"\"},\"nonce\":\"2021-11-26T12:30:00.000000Z\"}"}';
-        $this->assertSame($expectedString, $signedCommand->toString());
-    }
-}
diff --git a/tests/Unit/ValueObjects/HasCollectionMethodsTest.php b/tests/Unit/ValueObjects/HasCollectionMethodsTest.php
new file mode 100644
index 0000000..e8ba7b0
--- /dev/null
+++ b/tests/Unit/ValueObjects/HasCollectionMethodsTest.php
@@ -0,0 +1,88 @@
+<?php declare(strict_types=1);
+
+namespace Kadena\Tests\Unit\ValueObjects;
+
+use Carbon\Carbon;
+use Kadena\Contracts\Collection;
+use Kadena\ValueObjects\HasCollectionMethods;
+use PHPUnit\Framework\TestCase;
+
+final class HasCollectionMethodsTest extends TestCase
+{
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        Carbon::setTestNow('2021-11-26 12:30:00');
+    }
+
+    /** @test */
+    public function it_should_be_able_to_cast_a_collection_to_an_array(): void
+    {
+        $stringArray = [
+            'first',
+            'second',
+            'third',
+            'fourth',
+        ];
+
+        $collection = new TestCollection(...$stringArray);
+
+        $this->assertEquals($stringArray, $collection->toArray());
+    }
+
+    /** @test */
+    public function it_should_be_able_to_return_the_first_element_of_a_collection(): void
+    {
+        $stringArray = [
+            'first',
+            'second',
+            'third',
+            'fourth',
+        ];
+
+        $collection = new TestCollection(...$stringArray);
+
+        $this->assertEquals('first', $collection->first());
+    }
+
+    /** @test */
+    public function it_should_be_able_to_return_a_collection_element_at_a_given_key(): void
+    {
+        $stringArray = [
+            'first',
+            'second',
+            'third',
+            'fourth',
+        ];
+
+        $collection = new TestCollection(...$stringArray);
+
+        $this->assertEquals('third', $collection->get(2));
+    }
+
+    /** @test */
+    public function it_should_be_able_to_return_the_int_count_of_the_amount_of_elements_in_the_collection(): void
+    {
+        $stringArray = [
+            'first',
+            'second',
+            'third',
+            'fourth',
+        ];
+
+        $collection = new TestCollection(...$stringArray);
+
+        $this->assertEquals(4, $collection->count());
+    }
+}
+
+final class TestCollection implements Collection
+{
+    use HasCollectionMethods;
+
+    public function __construct(string ...$strings)
+    {
+        $this->array = $strings;
+    }
+}