vault-tree 0.3.4 → 0.6.0

data/features/keywords/external_key.feature

@@ -0,0 +1,24 @@
+Feature: External Key
+
+  EXTERNAL_KEY ensures your password is run through a secure hash before it is used to
+  lock contents. Hashing guarentees a properly padded vault key and keeps the locked vault
+  more secure if you have a weak password.
+
+  Scenario: Close And Open Using and External Key
+    Given the blank contract:
+      """javascript
+        {
+          "header": {},
+          "vaults": {
+            "message":{
+              "description": "Simple Congratulations Message",
+              "fill_with": "EXTERNAL_INPUT['msg']",
+              "lock_with": "EXTERNAL_KEY['secret']",
+              "unlock_with": "EXTERNAL_KEY['secret']",
+              "contents": ""
+            }
+          }
+        }
+      """
+    When I lock the external input in a vault using an external key
+    Then I can recover the input message using the same key

data/features/keywords/key.feature

@@ -20,13 +20,13 @@ Feature: Key
             "random_vault_key":{
               "description":"Random Number",
               "fill_with": "RANDOM_NUMBER",
-              "lock_with": "MASTER_PASSPHRASE",
-              "unlock_with": "MASTER_PASSPHRASE",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
               "contents": ""
               },
             "message":{
               "description": "Simple Congratulations Message",
-              "fill_with": "EXTERNAL_DATA",
+              "fill_with": "EXTERNAL_INPUT['msg']",
               "lock_with": "KEY['random_vault_key']",
               "unlock_with": "KEY['random_vault_key']",
               "contents": ""

data/features/keywords/random_number.feature

@@ -23,14 +23,14 @@ Scenario: Close And Open With Random Key
           "random_vault_key":{
             "description":"Random Number",
             "fill_with": "RANDOM_NUMBER",
-            "lock_with": "MASTER_PASSPHRASE",
-            "unlock_with": "MASTER_PASSPHRASE",
+            "lock_with": "UNLOCKED",
+            "unlock_with": "UNLOCKED",
             "contents": ""
             },
 
           "message_locked_with_random":{
             "description":"A simple message locked with a random number",
-            "fill_with": "EXTERNAL_DATA",
+            "fill_with": "EXTERNAL_INPUT['msg']",
             "lock_with": "KEY['random_vault_key']",
             "unlock_with": "KEY['random_vault_key']",
             "contents": ""

data/features/keywords/shamir_key_shares.feature

@@ -0,0 +1,29 @@
+Feature: Shamir Key Shares
+
+  ```
+    SHAMIR_KEY_SHARES
+  ```
+
+  is used to fill a vault with a collection of secret shares
+  that have been obtained by breaking up a random secret key
+  with the Shamir Secret Sharing Algorithm.
+
+  Scenario: Lock away a collection of shamir key shares
+    Given the blank contract:
+      """javascript
+        {
+          "header": {},
+          "vaults": {
+
+            "share_collection":{
+              "fill_with": "SHAMIR_KEY_SHARES['5','3']",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
+              "contents": ""
+            }
+          }
+        }
+      """
+    When I lock away the shamir key share collection
+    Then a random key is generated and split with the shamir secret sharing algorithm
+    And I can open the vault to recover the JSON representation of the secret shares

data/features/keywords/shamir_share.feature

@@ -0,0 +1,40 @@
+Feature: Shamir Share
+
+  Scenario: Lock Secret Shares in thier respective vaults
+    Given the blank contract:
+      """javascript
+        {
+          "header": {},
+          "vaults": {
+
+            "share_collection":{
+              "fill_with": "SHAMIR_KEY_SHARES['3','2']",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
+              "contents": ""
+            },
+            "share_1":{
+              "fill_with": "SHAMIR_SHARE['share_collection','1']",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
+              "contents": ""
+            },
+            "share_2":{
+              "fill_with": "SHAMIR_SHARE['share_collection','2']",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
+              "contents": ""
+            },
+            "share_3":{
+              "fill_with": "SHAMIR_SHARE['share_collection','3']",
+              "lock_with": "UNLOCKED",
+              "unlock_with": "UNLOCKED",
+              "contents": ""
+            }
+          }
+        }
+      """
+    When I lock away the shamir key share collection
+    Then a random key is generated and split with the shamir secret sharing algorithm
+    When I fill an individual vault with the SECRET_SHARES keyword
+    Then the library takes the approprate share from the collection vault and locks it away

data/features/keywords/split_key.feature

@@ -3,7 +3,7 @@ Feature: Split Key
   ```javascript
   SPLIT_KEY['id_1','id_2','id_3']
   ```
-  Split Key is a simple for of secret sharing. 
+  Split Key is a simple form of secret sharing.
 
 Scenario: Close And Open With Split Key
   Given the blank contract:
@@ -13,22 +13,22 @@ Scenario: Close And Open With Split Key
         "vaults": {
           "a_consent_key":{
             "fill_with": "RANDOM_NUMBER",
-            "lock_with": "EXTERNAL_DATA",
-            "unlock_with": "EXTERNAL_DATA",
+            "lock_with": "EXTERNAL_KEY['a_secret']",
+            "unlock_with": "EXTERNAL_KEY['a_secret']",
             "contents": ""
           },
 
           "b_consent_key":{
             "fill_with": "RANDOM_NUMBER",
-            "lock_with": "EXTERNAL_DATA",
-            "unlock_with": "EXTERNAL_DATA",
+            "lock_with": "EXTERNAL_KEY['b_secret']",
+            "unlock_with": "EXTERNAL_KEY['b_secret']",
             "contents": ""
           },
 
           "c_consent_key":{
             "fill_with": "RANDOM_NUMBER",
-            "lock_with": "EXTERNAL_DATA",
-            "unlock_with": "EXTERNAL_DATA",
+            "lock_with": "EXTERNAL_KEY['c_secret']",
+            "unlock_with": "EXTERNAL_KEY['c_secret']",
             "contents": ""
           },
 
@@ -40,7 +40,7 @@ Scenario: Close And Open With Split Key
           },
 
           "abc_consent_message":{
-            "fill_with": "EXTERNAL_DATA",
+            "fill_with": "EXTERNAL_INPUT['consent_message']",
             "lock_with": "KEY['abc_joint_consent_key']",
             "unlock_with": "KEY['abc_joint_consent_key']",
             "contents": ""
@@ -49,6 +49,7 @@ Scenario: Close And Open With Split Key
       }
     """
   And Consent keys for parties A, B, and C
-  When I lock a message in a vault using a split key
+  When I lock a away the consent keys
+  And I lock a message in a vault using a split key
   Then I can recover the message if each party gives consent
   And I cannot recover the message if one party fails to give consent

data/features/keywords/unlocked.feature

@@ -18,13 +18,13 @@ Scenario: Transfer Key Via Unlocked Vault
           "random_vault_key":{
             "description":"Random Number",
             "fill_with": "RANDOM_NUMBER",
-            "lock_with": "MASTER_PASSPHRASE",
-            "unlock_with": "MASTER_PASSPHRASE",
+            "lock_with": "UNLOCKED",
+            "unlock_with": "UNLOCKED",
             "contents": ""
             },
           "message_locked_with_random":{
             "description":"A simple message locked with a random number",
-            "fill_with": "EXTERNAL_DATA",
+            "fill_with": "EXTERNAL_INPUT['msg']",
             "lock_with": "KEY['random_vault_key']",
             "unlock_with": "KEY['random_vault_key']",
             "contents": ""

data/features/readme.md

@@ -3,4 +3,4 @@
 If you are coming to this page from a redirect and are unfamiliar with Vault Tree,
 take a look at the [Homepage] for an overview of the project.
 
-[Homepage]: http://vault-tree.org
+[Homepage]: http://vaulttree.github.io

data/features/steps/asymmetric_vault.steps.rb

@@ -1,41 +1,34 @@
-Given(/^Alice has the blank asymmetric vault contract$/) do
-  contract_path = VaultTree::PathHelpers.core_contracts('asymmetric_vault.0.1.0.json')
-  @contract_json = File.read(contract_path)
-end
-
-When(/^she locks all of her public and private keys$/) do
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'ALICE_SECURE_PASS', external_data: {})
-  @contract = @contract.close_vault('alice_contract_secret')
-  @contract = @contract.close_vault('alice_decryption_key')
-  @contract = @contract.close_vault('alice_public_encryption_key')
+When(/^Alice locks all of her public and private keys$/) do
+  @acs_key = "#{VaultTree::LockSmith.new(message: 'ALICE_SECURE_PASS').secure_hash}"
+  @contract = VaultTree::Contract.new(@contract).close_vault('alice_contract_secret', acs_key: @acs_key)
+  @contract = VaultTree::Contract.new(@contract).close_vault('alice_decryption_key', acs_key: @acs_key)
+  @contract = VaultTree::Contract.new(@contract).close_vault('alice_public_encryption_key', acs_key: @acs_key)
 end
 
 When(/^she sends the contract to Bob over the internet$/) do
-  @contract_json = @contract.as_json
-  @bobs_external_data = {"message" => "CONGRATS ALICE! YOU UNLOCKED THE SECRET MESSAGE WITH A DH KEY."}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'BOB_SECURE_PASS', external_data: @bobs_external_data)
+  @bcs_key = "#{VaultTree::LockSmith.new(message: 'BOB_SECURE_PASS').secure_hash}"
 end
 
 Then(/^Bob can access of her public keys but not her private keys$/) do
-  @contents = @contract.retrieve_contents('alice_public_encryption_key')
+  @contents = VaultTree::Contract.new(@contract).open_vault('alice_public_encryption_key')
 end
 
 When(/^Bob locks his public and private keys$/) do
-  @contract = @contract.close_vault('bob_decryption_key')
-  @contract = @contract.close_vault('bob_public_encryption_key')
+  @contract = VaultTree::Contract.new(@contract).close_vault('bob_decryption_key', bcs_key: @bcs_key)
+  @contract = VaultTree::Contract.new(@contract).close_vault('bob_public_encryption_key', bcs_key: @bcs_key)
 end
 
 When(/^He fills and locks the vault containing the message using a DH_KEY$/) do
-  @contract = @contract.close_vault('message')
+  @msg = "CONGRATS ALICE! YOU UNLOCKED THE SECRET MESSAGE WITH A DH KEY."
+  @contract = VaultTree::Contract.new(@contract).close_vault('message', msg: @msg, bcs_key: @bcs_key)
 end
 
 
 When(/^he sends the contract back to Alice over the internet$/) do
-  @contract_json = @contract.as_json
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'ALICE_SECURE_PASS', external_data: {})
+  @contract = VaultTree::Contract.new(@contract).as_json
 end
 
 Then(/^Alice can unlock the message with a DH_KEY$/) do
-  puts @contract.retrieve_contents('message')
-  @contract.retrieve_contents('message').should == @bobs_external_data['message']
+  puts VaultTree::Contract.new(@contract).open_vault('message', acs_key: @acs_key)
+  VaultTree::Contract.new(@contract).open_vault('message', acs_key: @acs_key).should == @msg
 end

data/features/steps/block_chain_key_transfer.steps.rb

@@ -1,43 +1,38 @@
 Given(/^the SENDER has the blank contract template$/) do
-  contract_path = VaultTree::PathHelpers.core_contracts('block_chain_key_transfer.0.1.0.json')
-  @contract_json = File.read(contract_path)
 end
 
 Given(/^the SENDER chooses an origin address and a concealed destination address$/) do
-  @sender_external_data =
-    {
-      'sender_origin_wallet_address' => '1XJEBF8EUBF855NEBHVENPFE9JE74E',
-      'sender_concealed_destination_wallet_address' => '1JVKE8HD5JDHFEJHF678JEH8DEJGHE',
-      'sender_btc_signing_key' => 'BITCOIN_SIGNING_KEY_KEEP_IT_SECRET'
-    }
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'SENDER_SECURE_PASS', external_data: @sender_external_data)
-  @contract = @contract.close_vault('sender_origin_wallet_address')
-  @contract = @contract.close_vault('sender_concealed_destination_wallet_address')
+  @sender_secret = "#{VaultTree::LockSmith.new(message: 'SENDER_SECURE_PASS').secure_hash}"
+  @sender_origin_wallet_address = '1XJEBF8EUBF855NEBHVENPFE9JE74E'
+  @sender_concealed_destination_wallet_address = '1JVKE8HD5JDHFEJHF678JEH8DEJGHE'
+  @sender_btc_signing_key = 'BITCOIN_SIGNING_KEY_KEEP_IT_SECRET'
+
+  @contract = VaultTree::Contract.new(@contract).close_vault('sender_concealed_destination_wallet_address', scdwa: @sender_concealed_destination_wallet_address, ss_key: @sender_secret)
+  @contract = VaultTree::Contract.new(@contract).close_vault('sender_origin_wallet_address', sowa: @sender_origin_wallet_address, ss_key: @sender_secret)
 end
 
 Given(/^he locks away the secret BTC signing key$/) do
-  @contract = @contract.close_vault('sender_btc_signing_key')
+  @contract = VaultTree::Contract.new(@contract).close_vault('sender_btc_signing_key', ssk: @sender_btc_signing_key, ss_key: @sender_secret)
 end
 
 When(/^the SENDER transfers the contract to the RECEIVER$/) do
-  @contract_json_over_the_wire = @contract.as_json
-  @contract = VaultTree::Contract.new(@contract_json_over_the_wire, master_passphrase: 'RECEIVER_SECURE_PASS')
+  @contract_json_over_the_wire = VaultTree::Contract.new(@contract).as_json
+  @contract = VaultTree::Contract.new(@contract_json_over_the_wire).as_json
 end
 
 Then(/^the RECEIVER can access the origin wallet address$/) do
-  @contract.retrieve_contents('sender_origin_wallet_address').should == @sender_external_data['sender_origin_wallet_address']
+  @receiver_secret = "#{VaultTree::LockSmith.new(message: 'RECEIVER_SECURE_PASS').secure_hash}"
+  VaultTree::Contract.new(@contract).open_vault('sender_origin_wallet_address', rs_key: @receiver_secret).should == @sender_origin_wallet_address
 end
 
 When(/^the SENDER reveals the hidden wallet address by transfering bitcoins from the origin address$/) do
-  @contract_json = @contract.as_json # save the json state
-  wallet_address_from_watching_blockchain = @sender_external_data['sender_concealed_destination_wallet_address']
-  @receiver_external_data = { 'receiver_revealed_destination_wallet_address' => wallet_address_from_watching_blockchain}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'RECEIVER_SECURE_PASS', external_data: @receiver_external_data)
-  @contract = @contract.close_vault('receiver_revealed_destination_wallet_address')
+  @contract = VaultTree::Contract.new(@contract).as_json # save the json state
+  wallet_address_from_watching_blockchain = @sender_concealed_destination_wallet_address # This is made public on the chain
+  @contract = VaultTree::Contract.new(@contract).close_vault('receiver_revealed_destination_wallet_address', rs_key: @receiver_secret, rrdwa: wallet_address_from_watching_blockchain)
 end
 
 Then(/^the RECEIVER can unlock the vault to recover the transfered signing key$/) do
-  transfered_secret_key = @contract.retrieve_contents('sender_btc_signing_key')
-  transfered_secret_key.should ==  @sender_external_data['sender_btc_signing_key']
+  transfered_secret_key = VaultTree::Contract.new(@contract).open_vault('sender_btc_signing_key', rs_key: @receiver_secret)
+  transfered_secret_key.should ==  @sender_btc_signing_key
   puts "PROPERLY TRANSFERED: #{transfered_secret_key} !"
 end

data/features/steps/core.steps.rb

@@ -1,121 +1,110 @@
-Given(/^I have a blank reference contract$/) do
-  contract_path = VaultTree::PathHelpers.reference_contract
-  @contract_json = File.read(contract_path)
-end
-
-When(/^I lock a message in a vault with my Master Password$/) do
-  @external_data = {"message" => "CONGRATS! YOU OPENED THE VAULT."}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS', external_data: @external_data)
-  @contract = @contract.close_vault('message')
-end
-
-Then(/^I can recover the message with my Master Password$/) do
-  @contract.retrieve_contents('message').should == @external_data['message']
-end
-
 When(/^I lock away a random vault key$/) do
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS')
-  @contract = @contract.close_vault('random_vault_key')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @contract = VaultTree::Contract.new(@contract).close_vault('random_vault_key')
 end
 
 When(/^I use the random key to lock a message$/) do
-  @external_data = {"message_locked_with_random" => "CONGRATS! YOU OPENED THE VAULT WITH A RANDOM KEY."}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS', external_data: @external_data)
-  @contract = @contract.close_vault('message_locked_with_random')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @msg = "CONGRATS! YOU OPENED THE VAULT."
+  @contract = VaultTree::Contract.new(@contract).close_vault('message_locked_with_random', msg: @msg)
 end
 
 Then(/^I can recover the message with the Random Key$/) do
-  @contract.retrieve_contents('message_locked_with_random').should == @external_data['message_locked_with_random']
+  VaultTree::Contract.new(@contract).open_vault('message_locked_with_random').should == @msg
 end
 
 When(/^I put this random key in an unlocked vault$/) do
-  @contract = @contract.close_vault('unlocked_random_key')
+  @contract = VaultTree::Contract.new(@contract).close_vault('unlocked_random_key')
 end
 
 Then(/^another user can recover the message with the Unlocked Random Key$/) do
-  @contract = @contract.close_vault('message_locked_with_unlocked_random_number')
-  @contract_json = @contract.as_json
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'ANOTHER_SECURE_PASS')
-  @contract.retrieve_contents('message_locked_with_unlocked_random_number').should == @external_data['message_locked_with_random']
+  @contract = VaultTree::Contract.new(@contract).close_vault('message_locked_with_unlocked_random_number')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  VaultTree::Contract.new(@contract).open_vault('message_locked_with_unlocked_random_number').should == @msg
 end
 
 Given(/^I have access to the another user's unlocked public key$/) do
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'ANOTHER_USERS_SECURE_PASS')
-  @contract = @contract.close_vault('another_decryption_key')
-  @contract = @contract.close_vault('another_public_key')
-  @contract_json = @contract.as_json
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS')
-  @contract = @contract.close_vault('my_decryption_key')
-  @contract = @contract.close_vault('my_public_key')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @contract = VaultTree::Contract.new(@contract).close_vault('another_decryption_key')
+  @contract = VaultTree::Contract.new(@contract).close_vault('another_public_key')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @contract = VaultTree::Contract.new(@contract).close_vault('my_decryption_key')
+  @contract = VaultTree::Contract.new(@contract).close_vault('my_public_key')
 end
 
 Given(/^I lock a simple message with a DH Key$/) do
-  @contract_json = @contract.as_json
-  @external_data = {"asymmetric_message" => "CONGRATS! YOU OPENED THE ASYMMETRIC VAULT."}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS', external_data: @external_data)
-  @contract = @contract.close_vault('asymmetric_message')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @asymmetric_message = "CONGRATS! YOU OPENED THE ASYMMETRIC VAULT."
+  @contract = VaultTree::Contract.new(@contract).close_vault('asymmetric_message', asymmetric_message: @asymmetric_message)
 end
 
 When(/^I transfer the contract to the other user$/) do
-  @contract_json = @contract.as_json
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'ANOTHER_USERS_SECURE_PASS')
+  @contract = VaultTree::Contract.new(@contract).as_json
 end
 
 Then(/^they can create a DH Key and unlock the message$/) do
-  @contract.retrieve_contents('asymmetric_message').should == @external_data['asymmetric_message']
+  VaultTree::Contract.new(@contract).open_vault('asymmetric_message').should == @asymmetric_message
 end
 
 Given(/^Consent keys for parties A, B, and C$/) do
-  @locking_consent_keys = {
-    "a_consent_key" => "A_SECRET_CONSENT_KEY",
-    "b_consent_key" => "B_SECRET_CONSENT_KEY",
-    "c_consent_key" => "C_SECRET_CONSENT_KEY"
-  }
+  @a_secret = "A_SECRET_CONSENT_KEY"
+  @b_secret = "B_SECRET_CONSENT_KEY"
+  @c_secret = "C_SECRET_CONSENT_KEY"
+end
+
+When(/^I lock a away the consent keys$/) do
+  @contract = VaultTree::Contract.new(@contract).close_vault('a_consent_key', a_secret: @a_secret)
+  @contract = VaultTree::Contract.new(@contract).close_vault('b_consent_key', b_secret: @b_secret)
+  @contract = VaultTree::Contract.new(@contract).close_vault('c_consent_key', c_secret: @c_secret)
+  @contract = VaultTree::Contract.new(@contract).as_json
 end
 
 When(/^I lock a message in a vault using a split key$/) do
-  @message = {"abc_consent_message" => "A, B, AND C ALL AGREED TO OPEN THE VAULT." }
-  @external_data = @locking_consent_keys.merge(@message)
-  @contract = VaultTree::Contract.new(@contract_json, external_data: @external_data)
-  @contract = @contract.close_vault('a_consent_key')
-  @contract = @contract.close_vault('b_consent_key')
-  @contract = @contract.close_vault('c_consent_key')
-  @contract = @contract.close_vault('abc_joint_consent_key')
-  @contract = @contract.close_vault('abc_consent_message')
-  @contract_json = @contract.as_json
+  @abc_consent_message = "A, B, AND C ALL AGREED TO OPEN THE VAULT."
+  @contract = VaultTree::Contract.new(@contract).close_vault('abc_joint_consent_key',
+                                     a_secret: @a_secret,
+                                     b_secret: @b_secret,
+                                     c_secret: @c_secret)
+  @contract = VaultTree::Contract.new(@contract).close_vault('abc_consent_message',
+                                     consent_message: @abc_consent_message,
+                                     a_secret: @a_secret,
+                                     b_secret: @b_secret,
+                                     c_secret: @c_secret)
+  @contract = VaultTree::Contract.new(@contract).as_json
 end
 
 Then(/^I can recover the message if each party gives consent$/) do
-  @unlocking_consent_keys = {
-    "a_consent_key" => "A_SECRET_CONSENT_KEY",
-    "b_consent_key" => "B_SECRET_CONSENT_KEY",
-    "c_consent_key" => "C_SECRET_CONSENT_KEY"
+  @unlocking_consent = {
+    a_secret: "A_SECRET_CONSENT_KEY",
+    b_secret: "B_SECRET_CONSENT_KEY",
+    c_secret: "C_SECRET_CONSENT_KEY"
   }
-  @contract = VaultTree::Contract.new(@contract_json, external_data: @unlocking_consent_keys)
-  @contract.retrieve_contents('abc_consent_message').should == @external_data['abc_consent_message']
-  puts @contract.retrieve_contents('abc_consent_message')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  VaultTree::Contract.new(@contract).open_vault('abc_consent_message', @unlocking_consent).should == @abc_consent_message
+  puts VaultTree::Contract.new(@contract).open_vault('abc_consent_message', @unlocking_consent)
 end
 
 Then(/^I cannot recover the message if one party fails to give consent$/) do
   @incomplete_unlocking_consent_keys = {
-    "a_consent_key" => "A_WRONG_SECRET_CONSENT_KEY",
-    "b_consent_key" => "B_SECRET_CONSENT_KEY",
-    "c_consent_key" => "C_SECRET_CONSENT_KEY"
+    a_secret: "A_WRONG_SECRET_CONSENT_KEY",
+    b_secret: "B_SECRET_CONSENT_KEY",
+    c_secret: "C_SECRET_CONSENT_KEY"
   }
-  @contract = VaultTree::Contract.new(@contract_json, external_data: @incomplete_unlocking_consent_keys)
-  expect{@contract.retrieve_contents('abc_consent_message')}.to raise_error(VaultTree::Exceptions::FailedUnlockAttempt)
+  @contract = VaultTree::Contract.new(@contract).as_json
+  expect{VaultTree::Contract.new(@contract).open_vault('abc_consent_message',@incomplete_unlocking_consent_keys)}.to raise_error(VaultTree::Exceptions::FailedUnlockAttempt)
 end
 
 Given(/^the blank contract:$/) do |string|
-  @contract_json = string
+  @contract = string
 end
 
 When(/^I lock a message in a vault using a symmetric vault key$/) do
-  @external_data = {"message" => "CONGRATS! YOU OPENED THE VAULT."}
-  @contract = VaultTree::Contract.new(@contract_json, master_passphrase: 'MY_SECURE_PASS', external_data: @external_data)
-  @contract = @contract.close_vault('message')
+  @contract = VaultTree::Contract.new(@contract).as_json
+  @msg = "CONGRATS! YOU OPENED THE VAULT."
+  @contract = VaultTree::Contract.new(@contract).close_vault('message', msg: @msg)
 end
 
 Then(/^I can recover the message using the same key$/) do
-  @contract.retrieve_contents('message').should == @external_data['message']
+  VaultTree::Contract.new(@contract).open_vault('message').should == @msg
 end