diff --git a/contracts/LPVault.sol b/contracts/LPVault.sol
index 674447b..3fc16c4 100644
--- a/contracts/LPVault.sol
+++ b/contracts/LPVault.sol
@@ -12,8 +12,8 @@ import "./Owned.sol";
 /// @dev `LiquidPledging` is a basic interface to allow the `LPVault` contract
 ///  to confirm and cancel payments in the `LiquidPledging` contract.
 contract LiquidPledging {
-    function confirmPayment(uint64 idNote, uint amount) public;
-    function cancelPayment(uint64 idNote, uint amount) public;
+    function confirmPayment(uint64 idPledge, uint amount) public;
+    function cancelPayment(uint64 idPledge, uint amount) public;
 }
 
 
diff --git a/contracts/LiquidPledging.sol b/contracts/LiquidPledging.sol
index 705eec0..4995e2f 100644
--- a/contracts/LiquidPledging.sol
+++ b/contracts/LiquidPledging.sol
@@ -103,15 +103,15 @@ contract LiquidPledging is LiquidPledgingBase {
 
         idPledge = normalizePledge(idPledge);
 
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
         PledgeAdmin storage receiver = findAdmin(idReceiver);
         PledgeAdmin storage sender = findAdmin(idSender);
 
         checkAdminOwner(sender);
-        require(n.pledgeState == PledgeState.Pledged);
+        require(p.pledgeState == PledgeState.Pledged);
 
         // If the sender is the owner
-        if (n.owner == idSender) {
+        if (p.owner == idSender) {
             if (receiver.adminType == PledgeAdminType.Giver) {
                 transferOwnershipToGiver(idPledge, amount, idReceiver);
             } else if (receiver.adminType == PledgeAdminType.Project) {
@@ -120,7 +120,7 @@ contract LiquidPledging is LiquidPledgingBase {
                 idPledge = undelegate(
                     idPledge,
                     amount,
-                    n.delegationChain.length
+                    p.delegationChain.length
                 );
                 appendDelegate(idPledge, amount, idReceiver);
             } else {
@@ -130,28 +130,28 @@ contract LiquidPledging is LiquidPledgingBase {
         }
 
         // If the sender is a delegate
-        uint senderDIdx = getDelegateIdx(n, idSender);
+        uint senderDIdx = getDelegateIdx(p, idSender);
         if (senderDIdx != NOTFOUND) {
 
             // If the receiver is another giver
             if (receiver.adminType == PledgeAdminType.Giver) {
                 // Only accept to change to the original giver to
                 // remove all delegates
-                assert(n.owner == idReceiver);
-                undelegate(idPledge, amount, n.delegationChain.length);
+                assert(p.owner == idReceiver);
+                undelegate(idPledge, amount, p.delegationChain.length);
                 return;
             }
 
             // If the receiver is another delegate
             if (receiver.adminType == PledgeAdminType.Delegate) {
-                uint receiverDIdx = getDelegateIdx(n, idReceiver);
+                uint receiverDIdx = getDelegateIdx(p, idReceiver);
 
                 // If the receiver is not in the delegate list
                 if (receiverDIdx == NOTFOUND) {
                     idPledge = undelegate(
                         idPledge,
                         amount,
-                        n.delegationChain.length - senderDIdx - 1
+                        p.delegationChain.length - senderDIdx - 1
                     );
                     appendDelegate(idPledge, amount, idReceiver);
 
@@ -163,7 +163,7 @@ contract LiquidPledging is LiquidPledgingBase {
                     idPledge = undelegate(
                         idPledge,
                         amount,
-                        n.delegationChain.length - senderDIdx - 1
+                        p.delegationChain.length - senderDIdx - 1
                     );
                     appendDelegate(idPledge, amount, idReceiver);
 
@@ -177,7 +177,7 @@ contract LiquidPledging is LiquidPledgingBase {
                     undelegate(
                         idPledge,
                         amount,
-                        n.delegationChain.length - receiverDIdx - 1
+                        p.delegationChain.length - receiverDIdx - 1
                     );
                 }
                 return;
@@ -189,7 +189,7 @@ contract LiquidPledging is LiquidPledgingBase {
                 idPledge = undelegate(
                     idPledge,
                     amount,
-                    n.delegationChain.length - senderDIdx - 1
+                    p.delegationChain.length - senderDIdx - 1
                 );
                 proposeAssignProject(idPledge, amount, idReceiver);
                 return;
@@ -206,20 +206,20 @@ contract LiquidPledging is LiquidPledgingBase {
 
         idPledge = normalizePledge(idPledge);
 
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
-        require(n.pledgeState == PledgeState.Pledged);
+        require(p.pledgeState == PledgeState.Pledged);
 
-        PledgeAdmin storage owner = findAdmin(n.owner);
+        PledgeAdmin storage owner = findAdmin(p.owner);
 
         checkAdminOwner(owner);
 
         uint64 idNewPledge = findOrCreatePledge(
-            n.owner,
-            n.delegationChain,
+            p.owner,
+            p.delegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Paying
         );
 
@@ -232,16 +232,16 @@ contract LiquidPledging is LiquidPledgingBase {
     /// @param idPledge Id of the pledge that wants to be withdrawn.
     /// @param amount Quantity of Ether that wants to be withdrawn.
     function confirmPayment(uint64 idPledge, uint amount) onlyVault {
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
-        require(n.pledgeState == PledgeState.Paying);
+        require(p.pledgeState == PledgeState.Paying);
 
         uint64 idNewPledge = findOrCreatePledge(
-            n.owner,
-            n.delegationChain,
+            p.owner,
+            p.delegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Paid
         );
 
@@ -252,17 +252,17 @@ contract LiquidPledging is LiquidPledgingBase {
     /// @param idPledge Id of the pledge that wants to be canceled for withdraw.
     /// @param amount Quantity of Ether that wants to be rolled back.
     function cancelPayment(uint64 idPledge, uint amount) onlyVault {
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
-        require(n.pledgeState == PledgeState.Paying); //TODO change to revert
+        require(p.pledgeState == PledgeState.Paying); //TODO change to revert
 
         // When a payment is canceled, never is assigned to a project.
         uint64 oldPledge = findOrCreatePledge(
-            n.owner,
-            n.delegationChain,
+            p.owner,
+            p.delegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Pledged
         );
 
@@ -287,13 +287,13 @@ contract LiquidPledging is LiquidPledgingBase {
     function cancelPledge(uint64 idPledge, uint amount) {
         idPledge = normalizePledge(idPledge);
 
-        Pledge storage n = findPledge(idPledge);
-        require(n.oldPledge != 0);
+        Pledge storage p = findPledge(idPledge);
+        require(p.oldPledge != 0);
 
-        PledgeAdmin storage m = findAdmin(n.owner);
+        PledgeAdmin storage m = findAdmin(p.owner);
         checkAdminOwner(m);
 
-        uint64 oldPledge = getOldestPledgeNotCanceled(n.oldPledge);
+        uint64 oldPledge = getOldestPledgeNotCanceled(p.oldPledge);
         doTransfer(idPledge, oldPledge, amount);
     }
 
@@ -395,19 +395,19 @@ contract LiquidPledging is LiquidPledgingBase {
         uint amount,
         uint64 idReceiver
     ) internal {
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
         // Ensure that the pledge is not already at max pledge depth
         // and the project has not been canceled
-        require(getPledgeLevel(n) < MAX_INTERPROJECT_LEVEL);
+        require(getPledgeLevel(p) < MAX_INTERPROJECT_LEVEL);
         require(!isProjectCanceled(idReceiver));
 
         uint64 oldPledge = findOrCreatePledge(
-            n.owner,
-            n.delegationChain,
+            p.owner,
+            p.delegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Pledged
         );
         uint64 toPledge = findOrCreatePledge(
@@ -454,25 +454,25 @@ contract LiquidPledging is LiquidPledgingBase {
         uint amount,
         uint64 idReceiver
     ) internal {
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
-        require(n.delegationChain.length < MAX_DELEGATES);
+        require(p.delegationChain.length < MAX_DELEGATES);
         uint64[] memory newDelegationChain = new uint64[](
-            n.delegationChain.length + 1
+            p.delegationChain.length + 1
         );
-        for (uint i = 0; i<n.delegationChain.length; i++) {
-            newDelegationChain[i] = n.delegationChain[i];
+        for (uint i = 0; i<p.delegationChain.length; i++) {
+            newDelegationChain[i] = p.delegationChain[i];
         }
 
         // Make the last item in the array the idReceiver
-        newDelegationChain[n.delegationChain.length] = idReceiver;
+        newDelegationChain[p.delegationChain.length] = idReceiver;
 
         uint64 toPledge = findOrCreatePledge(
-            n.owner,
+            p.owner,
             newDelegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Pledged
         );
         doTransfer(idPledge, toPledge, amount);
@@ -488,19 +488,19 @@ contract LiquidPledging is LiquidPledgingBase {
         uint amount,
         uint q
     ) internal returns (uint64){
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
         uint64[] memory newDelegationChain = new uint64[](
-            n.delegationChain.length - q
+            p.delegationChain.length - q
         );
-        for (uint i=0; i<n.delegationChain.length - q; i++) {
-            newDelegationChain[i] = n.delegationChain[i];
+        for (uint i=0; i<p.delegationChain.length - q; i++) {
+            newDelegationChain[i] = p.delegationChain[i];
         }
         uint64 toPledge = findOrCreatePledge(
-            n.owner,
+            p.owner,
             newDelegationChain,
             0,
             0,
-            n.oldPledge,
+            p.oldPledge,
             PledgeState.Pledged
         );
         doTransfer(idPledge, toPledge, amount);
@@ -520,17 +520,17 @@ contract LiquidPledging is LiquidPledgingBase {
         uint amount,
         uint64 idReceiver
     ) internal {
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
-        require(getPledgeLevel(n) < MAX_SUBPROJECT_LEVEL);
+        require(getPledgeLevel(p) < MAX_SUBPROJECT_LEVEL);
         require(!isProjectCanceled(idReceiver));
 
         uint64 toPledge = findOrCreatePledge(
-            n.owner,
-            n.delegationChain,
+            p.owner,
+            p.delegationChain,
             idReceiver,
-            uint64(getTime() + maxCommitTime(n)),
-            n.oldPledge,
+            uint64(getTime() + maxCommitTime(p)),
+            p.oldPledge,
             PledgeState.Pledged
         );
         doTransfer(idPledge, toPledge, amount);
@@ -578,40 +578,40 @@ contract LiquidPledging is LiquidPledgingBase {
     /// @param idPledge This is the id of the pledge that will be normalized
     function normalizePledge(uint64 idPledge) returns(uint64) {
 
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
         // Check to make sure this pledge hasn't already been used 
         // or is in the process of being used
-        if (n.pledgeState != PledgeState.Pledged) {
+        if (p.pledgeState != PledgeState.Pledged) {
             return idPledge;
         }
 
         // First send to a project if it's proposed and committed
-        if ((n.intendedProject > 0) && ( getTime() > n.commitTime)) {
+        if ((p.intendedProject > 0) && ( getTime() > p.commitTime)) {
             uint64 oldPledge = findOrCreatePledge(
-                n.owner,
-                n.delegationChain,
+                p.owner,
+                p.delegationChain,
                 0,
                 0,
-                n.oldPledge,
+                p.oldPledge,
                 PledgeState.Pledged
             );
             uint64 toPledge = findOrCreatePledge(
-                n.intendedProject,
+                p.intendedProject,
                 new uint64[](0),
                 0,
                 0,
                 oldPledge,
                 PledgeState.Pledged
             );
-            doTransfer(idPledge, toPledge, n.amount);
+            doTransfer(idPledge, toPledge, p.amount);
             idPledge = toPledge;
-            n = findPledge(idPledge);
+            p = findPledge(idPledge);
         }
 
         toPledge = getOldestPledgeNotCanceled(idPledge);// TODO toPledge is pledge defined
         if (toPledge != idPledge) {
-            doTransfer(idPledge, toPledge, n.amount);
+            doTransfer(idPledge, toPledge, p.amount);
         }
 
         return toPledge;
@@ -695,12 +695,12 @@ contract LiquidPledging is LiquidPledgingBase {
         // or transferring context
         uint64 offset = idPledge == fromPledge ? 0 : 256;
         allowedAmount = amount;
-        Pledge storage n = findPledge(idPledge);
+        Pledge storage p = findPledge(idPledge);
 
         // Always call the plugin on the owner
         allowedAmount = callPlugin(
             before,
-            n.owner,
+            p.owner,
             fromPledge,
             toPledge,
             offset,
@@ -708,10 +708,10 @@ contract LiquidPledging is LiquidPledgingBase {
         );
 
         // Apply call plugin to all delegates
-        for (uint64 i=0; i<n.delegationChain.length; i++) {
+        for (uint64 i=0; i<p.delegationChain.length; i++) {
             allowedAmount = callPlugin(
                 before,
-                n.delegationChain[i],
+                p.delegationChain[i],
                 fromPledge,
                 toPledge,
                 offset + i+1,
@@ -722,10 +722,10 @@ contract LiquidPledging is LiquidPledgingBase {
         // If there is an intended project also call the plugin in
         // either a transferring or receiving context based on offset
         // on the intended project
-        if (n.intendedProject > 0) {
+        if (p.intendedProject > 0) {
             allowedAmount = callPlugin(
                 before,
-                n.intendedProject,
+                p.intendedProject,
                 fromPledge,
                 toPledge,
                 offset + 255,
diff --git a/contracts/LiquidPledgingBase.sol b/contracts/LiquidPledgingBase.sol
index 530b6b0..c56f71a 100644
--- a/contracts/LiquidPledgingBase.sol
+++ b/contracts/LiquidPledgingBase.sol
@@ -338,14 +338,14 @@ contract LiquidPledgingBase is Owned {
         uint64 oldPledge,
         PledgeState pledgeState
     ) {
-        Pledge storage n = findPledge(idPledge);
-        amount = n.amount;
-        owner = n.owner;
-        nDelegates = uint64(n.delegationChain.length);
-        intendedProject = n.intendedProject;
-        commitTime = n.commitTime;
-        oldPledge = n.oldPledge;
-        pledgeState = n.pledgeState;
+        Pledge storage p = findPledge(idPledge);
+        amount = p.amount;
+        owner = p.owner;
+        nDelegates = uint64(p.delegationChain.length);
+        intendedProject = p.intendedProject;
+        commitTime = p.commitTime;
+        oldPledge = p.oldPledge;
+        pledgeState = p.pledgeState;
     }
 
     /// @notice Getter to find Delegate w/ the Pledge ID & the Delegate index
@@ -356,8 +356,8 @@ contract LiquidPledgingBase is Owned {
         address addr,
         string name
     ) {
-        Pledge storage n = findPledge(idPledge);
-        idDelegate = n.delegationChain[idxDelegate - 1];
+        Pledge storage p = findPledge(idPledge);
+        idDelegate = p.delegationChain[idxDelegate - 1];
         PledgeAdmin storage delegate = findAdmin(idDelegate);
         addr = delegate.addr;
         name = delegate.name;
@@ -464,39 +464,39 @@ contract LiquidPledgingBase is Owned {
 
     /// @notice A getter that searches the delegationChain for the level of
     ///  authority a specific delegate has within a Pledge
-    /// @param n The Pledge that will be searched
+    /// @param p The Pledge that will be searched
     /// @param idDelegate The specified delegate that's searched for
     /// @return If the delegate chain contains the delegate with the
     ///  `admins` array index `idDelegate` this returns that delegates
     ///  corresponding index in the delegationChain. Otherwise it returns
     ///  the NOTFOUND constant
-    function getDelegateIdx(Pledge n, uint64 idDelegate) internal returns(uint64) {
-        for (uint i=0; i < n.delegationChain.length; i++) {
-            if (n.delegationChain[i] == idDelegate) return uint64(i);
+    function getDelegateIdx(Pledge p, uint64 idDelegate) internal returns(uint64) {
+        for (uint i=0; i < p.delegationChain.length; i++) {
+            if (p.delegationChain[i] == idDelegate) return uint64(i);
         }
         return NOTFOUND;
     }
 
     /// @notice A getter to find how many old "parent" pledges a specific Pledge
     ///  had using a self-referential loop
-    /// @param n The Pledge being queried
+    /// @param p The Pledge being queried
     /// @return The number of old "parent" pledges a specific Pledge had
-    function getPledgeLevel(Pledge n) internal returns(uint) {
-        if (n.oldPledge == 0) return 0;
-        Pledge storage oldN = findPledge(n.oldPledge);
+    function getPledgeLevel(Pledge p) internal returns(uint) {
+        if (p.oldPledge == 0) return 0;
+        Pledge storage oldN = findPledge(p.oldPledge);
         return getPledgeLevel(oldN) + 1; // a loop lookup
     }
 
     /// @notice A getter to find the longest commitTime out of the owner and all
     ///  the delegates for a specified pledge
-    /// @param n The Pledge being queried
+    /// @param p The Pledge being queried
     /// @return The maximum commitTime out of the owner and all the delegates
-    function maxCommitTime(Pledge n) internal returns(uint commitTime) {
-        PledgeAdmin storage m = findAdmin(n.owner);
+    function maxCommitTime(Pledge p) internal returns(uint commitTime) {
+        PledgeAdmin storage m = findAdmin(p.owner);
         commitTime = m.commitTime; // start with the owner's commitTime
 
-        for (uint i=0; i<n.delegationChain.length; i++) {
-            m = findAdmin(n.delegationChain[i]);
+        for (uint i=0; i<p.delegationChain.length; i++) {
+            m = findAdmin(p.delegationChain[i]);
 
             // If a delegate's commitTime is longer, make it the new commitTime
             if (m.commitTime > commitTime) commitTime = m.commitTime;
@@ -532,15 +532,15 @@ contract LiquidPledgingBase is Owned {
     function getOldestPledgeNotCanceled(uint64 idPledge
         ) internal constant returns(uint64) {
         if (idPledge == 0) return 0;
-        Pledge storage n = findPledge(idPledge);
-        PledgeAdmin storage admin = findAdmin(n.owner);
+        Pledge storage p = findPledge(idPledge);
+        PledgeAdmin storage admin = findAdmin(p.owner);
         if (admin.adminType == PledgeAdminType.Giver) return idPledge;
 
         assert(admin.adminType == PledgeAdminType.Project);
 
-        if (!isProjectCanceled(n.owner)) return idPledge;
+        if (!isProjectCanceled(p.owner)) return idPledge;
 
-        return getOldestPledgeNotCanceled(n.oldPledge);
+        return getOldestPledgeNotCanceled(p.oldPledge);
     }
 
     /// @notice A check to see if the msg.sender is the owner or the