Ctrlk

Another Shared Wallet Script

The previous example used the POSIXTime type as the script parameter. For the following example, we will look at custom-defined parameter types as there is some extra work we need to do in that case. We will transform the SharedWallet script from earlier to be parameterised instead of relying on the UTxO datum. That means that either of the trusted parties can spend any UTxO sitting at the script address, regardless of what the datum associated is.

Writing the validator

Firstly, we create the same type as before, this time calling it sharedParam:

data SharedWalletParam = SharedWalletParam {
    wallet1 :: Plutus.PubKeyHash,
    wallet2 :: Plutus.PubKeyHash
}

As before, we need to make our parameter type an instance of ToData/FromData via PlutusTx.unstableMakeIsData:

PlutusTx.unstableMakeIsData ''SharedWalletParam

In addition, when defining custom parameter types, we need to make them an instance of the Lift class. This allows the type to be lifted into so-called Plutus IR (intermediate representation), which is then handled further to Plutus Core, but essentially, we just need this to allow the compiler to compile our type to Plutus Core. This is done with the PlutusTx.makeLift function that automatically derives an instance for us:

PlutusTx.makeLift ''SharedWalletParam

Note that PubKeyHash type is an instance of both ToData/FromData and Lift, but our defined type SharedParam which contains two PubKeyHash fields is not.

The rest is pretty much the same as in the typed validator version. We need to create a ValidatorTypes instance, but since we are using a parameter that will bake our sharedParam inside the script, we do not need datum and redeemer:

data SharedWalletParamValidator
instance Scripts.ValidatorTypes SharedWalletParamValidator
    -- default types for datum and redeemer are ()

Our mkValidator function still for valid signatures in the transaction context, except this time the PubKeyHashes are deconstructed from the SharedParam argument:

{-# INLINEABLE mkValidator #-}
mkValidator :: SharedWalletParam -> () -> () -> Plutus.ScriptContext -> Bool
mkValidator swp () () ctx = checkSignature1 || checkSignature2
  where
    info :: Plutus.TxInfo
    info = Plutus.scriptContextTxInfo ctx

    signature1 :: PubKeyHash
    signature1 = wallet1 swp

    signature2 :: PubKeyHash
    signature2 = wallet2 swp

    checkSignature1 :: Bool
    checkSignature1 = traceIfFalse "signature 1 missing" $ txSignedBy info signature1

    checkSignature2 :: Bool
    checkSignature2 = traceIfFalse "signature 2 missing" $ txSignedBy info signature2

As with the parameterised deadline script example, we use the PSU.V2.mkTypedValidatorParam to define a function that accepts the parameter to compile the validator.

Besides the DataKind extension we enabled when working with typed validators, for parameterised validators we also need to enable ScopedTypeVariables and MultiParamTypeClasses.

Finally, we define the functions to serialise and write the script file:

In order to compile this validator, we need to provide it with a parameter of type SharedWalletParam. Again, we can export this type and its constructor by adding it to the module interface.

Now, when we load the module in a REPL, we can construct a valid SharedWalletParam type. Let's do that by specifying the two public key hashes from our addresses as we did with the typed version of the shared wallet validator. When we have our parameter for the script, we can pass it to the writeSerialisedScript function.

Testing the validator

As always, we start off by creating the script address in testnet/SharedWalletParam/create-script-address.sh.

Next, let's get an overview of the UTxOs with check-utxos.sh.

We can now send some funds to the script. Remember, we don't care about the datum as the script was parameterised at compilation so it knows about our public key hashes. However, we always have to attach a datum to any script UTxO or it will be unspendable, so we can attach our unit.json in the transaction constructed by the send-funds-to-script.sh script.

We see the UTxO at the script address so we can try spending it by simply signing the transaction with one of our private keys. Let's use the key from the 02.addr and use one of its UTxOs for collateral as well in spend-script-funds.sh.

And we can successfully spend the funds from the script using the 02.addr signing key!

PreviousA Deadline ScriptNextOverview

Last updated