@meshsdk/contract 1.6.0-alpha.11

package/src/vesting/aiken-workspace/aiken.toml

@@ -0,0 +1,19 @@
+name = "meshjs/vesting"
+version = "0.0.0"
+license = "Apache-2.0"
+description = "Aiken contracts for project 'meshjs/vesting'"
+
+[repository]
+user = "meshjs"
+project = "vesting"
+platform = "github"
+
+[[dependencies]]
+name = "aiken-lang/stdlib"
+version = "1.9.0"
+source = "github"
+
+[[dependencies]]
+name = "sidan-lab/aiken-utils"
+version = "0.1.6-beta"
+source = "github"

package/src/vesting/aiken-workspace/lib/vesting/types.ak

@@ -0,0 +1,8 @@
+pub type VestingDatum {
+  /// POSIX time in second, e.g. 1672843961000
+  lock_until: Int,
+  /// Owner's credentials
+  owner: ByteArray,
+  /// Beneficiary's credentials
+  beneficiary: ByteArray,
+}

package/src/vesting/aiken-workspace/lib/vesting/validators/vesting.ak

@@ -0,0 +1,19 @@
+use aiken/transaction.{ScriptContext, Spend, Transaction}
+use sidan_utils/extra_signatories.{key_signed}
+use sidan_utils/validity_range.{valid_after}
+use vesting/types.{VestingDatum}
+
+pub fn vesting_logic(datum: VestingDatum, ctx: ScriptContext) {
+  // In principle, scripts can be used for different purpose (e.g. minting
+  // assets). Here we make sure it's only used when 'spending' from a eUTxO
+  when ctx.purpose is {
+    Spend(_) -> or {
+        key_signed(ctx.transaction.extra_signatories, datum.owner),
+        and {
+          key_signed(ctx.transaction.extra_signatories, datum.beneficiary),
+          valid_after(ctx.transaction.validity_range, datum.lock_until),
+        },
+      }
+    _ -> False
+  }
+}

package/src/vesting/aiken-workspace/plutus.json

@@ -0,0 +1,67 @@
+{
+  "preamble": {
+    "title": "meshjs/vesting",
+    "description": "Aiken contracts for project 'meshjs/vesting'",
+    "version": "0.0.0",
+    "plutusVersion": "v2",
+    "compiler": {
+      "name": "Aiken",
+      "version": "v1.0.29-alpha+unknown"
+    },
+    "license": "Apache-2.0"
+  },
+  "validators": [
+    {
+      "title": "vesting.vesting",
+      "datum": {
+        "title": "datum",
+        "schema": {
+          "$ref": "#/definitions/vesting~1types~1VestingDatum"
+        }
+      },
+      "redeemer": {
+        "title": "_redeemer",
+        "schema": {
+          "$ref": "#/definitions/ByteArray"
+        }
+      },
+      "compiledCode": "5901c801000032323232323232232232253330063232323253323300b3001300c3754600a601a6ea801854ccc02ccc010dd6180198069baa3002300d375400c6eb8c014c034dd50050a511533300b3300437586006601a6ea8c008c034dd50031bae301030113011300d3754014266446464646464a666024601060266ea80084c94ccc04c0104cdc40038008011bad301730143754004002264a666024601060266ea80084c94ccc04c0100084cdc48038009bad3017301437540040022940c054008cdc42400060206ea8c050c054004cc048c04c004cc048ccc038cdc424000601e6ea8c04cc05000530103d87a80004c0103d87980004bd7018079baa3004300f375400460206022602260226022602260226022601a6ea8c008c034dd50031bad3002300d37540142940dc3a400429408c03c0048c038c03cc03cc03cc03cc03cc03cc03cc03c00488c8cc00400400c894ccc038004528099299980619b8f375c602200400829444cc00c00c004c0440048c030c03400452613656375c002a66600466e1d2000300337540022646464646464a666016601c0042930b1bae300c001300c002375c601400260140046eb4c020004c010dd50008b2b9a5573aaae7955cfaba05742ae89",
+      "hash": "5978a5118ecb36ad827390a21769bfa680ffc499d364bad913b4dffa"
+    }
+  ],
+  "definitions": {
+    "ByteArray": {
+      "dataType": "bytes"
+    },
+    "Int": {
+      "dataType": "integer"
+    },
+    "vesting/types/VestingDatum": {
+      "title": "VestingDatum",
+      "anyOf": [
+        {
+          "title": "VestingDatum",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "title": "lock_until",
+              "description": "POSIX time in second, e.g. 1672843961000",
+              "$ref": "#/definitions/Int"
+            },
+            {
+              "title": "owner",
+              "description": "Owner's credentials",
+              "$ref": "#/definitions/ByteArray"
+            },
+            {
+              "title": "beneficiary",
+              "description": "Beneficiary's credentials",
+              "$ref": "#/definitions/ByteArray"
+            }
+          ]
+        }
+      ]
+    }
+  }
+}

package/src/vesting/aiken-workspace/validators/tests/vesting.ak

@@ -0,0 +1,108 @@
+use aiken/transaction.{ScriptContext, Spend}
+use sidan_placeholder/builder.{
+  complete, invalid_before, new_tx_tester, required_signer_hash,
+}
+use sidan_placeholder/key_hex.{mock_pub_key_hex}
+use sidan_placeholder/output_reference.{mock_utxo_ref}
+use vesting/types.{VestingDatum}
+use vesting/validators/vesting.{vesting_logic}
+
+type TestCase {
+  is_owner_signed: Bool,
+  is_beneficiary_signed: Bool,
+  is_lock_time_passed: Bool,
+}
+
+fn get_test_tx(test_case: TestCase) {
+  let TestCase { is_owner_signed, is_beneficiary_signed, is_lock_time_passed } =
+    test_case
+
+  new_tx_tester()
+    |> required_signer_hash(is_owner_signed, mock_pub_key_hex(1))
+    |> required_signer_hash(is_beneficiary_signed, mock_pub_key_hex(2))
+    |> invalid_before(is_lock_time_passed, 1672843961001)
+    |> complete()
+}
+
+fn vesting_datum() {
+  VestingDatum {
+    lock_until: 1672843961000,
+    owner: mock_pub_key_hex(1),
+    beneficiary: mock_pub_key_hex(2),
+  }
+}
+
+test success_unlocking() {
+  let output_reference = mock_utxo_ref(0, 1)
+  let datum = vesting_datum()
+  let test_case =
+    TestCase {
+      is_owner_signed: True,
+      is_beneficiary_signed: True,
+      is_lock_time_passed: True,
+    }
+
+  let tx = get_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  vesting_logic(datum, ctx)
+}
+
+test success_unlocking_with_only_owner_signature() {
+  let output_reference = mock_utxo_ref(0, 1)
+  let datum = vesting_datum()
+  let test_case =
+    TestCase {
+      is_owner_signed: True,
+      is_beneficiary_signed: False,
+      is_lock_time_passed: False,
+    }
+
+  let tx = get_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  vesting_logic(datum, ctx)
+}
+
+test success_unlocking_with_beneficiary_signature_and_time_passed() {
+  let output_reference = mock_utxo_ref(0, 1)
+  let datum = vesting_datum()
+  let test_case =
+    TestCase {
+      is_owner_signed: False,
+      is_beneficiary_signed: True,
+      is_lock_time_passed: True,
+    }
+
+  let tx = get_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  vesting_logic(datum, ctx)
+}
+
+test fail_unlocking_with_only_beneficiary_signature() {
+  let output_reference = mock_utxo_ref(0, 1)
+  let datum = vesting_datum()
+  let test_case =
+    TestCase {
+      is_owner_signed: False,
+      is_beneficiary_signed: True,
+      is_lock_time_passed: False,
+    }
+
+  let tx = get_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !vesting_logic(datum, ctx)
+}
+
+test fail_unlocking_with_only_time_passed() {
+  let output_reference = mock_utxo_ref(0, 1)
+  let datum = vesting_datum()
+  let test_case =
+    TestCase {
+      is_owner_signed: False,
+      is_beneficiary_signed: False,
+      is_lock_time_passed: True,
+    }
+
+  let tx = get_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !vesting_logic(datum, ctx)
+}

package/src/vesting/aiken-workspace/validators/vesting.ak

@@ -0,0 +1,9 @@
+use aiken/transaction.{ScriptContext}
+use vesting/types.{VestingDatum}
+use vesting/validators/vesting.{vesting_logic}
+
+validator {
+  fn vesting(datum: VestingDatum, _redeemer: ByteArray, ctx: ScriptContext) {
+    vesting_logic(datum, ctx)
+  }
+}

package/src/vesting/index.ts

@@ -0,0 +1 @@
+export * from './offchain';

package/src/vesting/offchain.ts

@@ -0,0 +1,117 @@
+import {
+  BuiltinByteString,
+  ConStr0,
+  Integer,
+  mConStr0,
+  SLOT_CONFIG_NETWORK,
+  unixTimeToEnclosingSlot,
+} from "@meshsdk/common";
+import {
+  Asset,
+  deserializeAddress,
+  deserializeDatum,
+  serializePlutusScript,
+  UTxO,
+} from "@meshsdk/core";
+import { applyParamsToScript } from "@meshsdk/core-csl";
+
+import { MeshTxInitiator, MeshTxInitiatorInput } from "../common";
+import blueprint from "./aiken-workspace/plutus.json";
+
+export const MeshVestingBlueprint = blueprint;
+
+export type VestingDatum = ConStr0<
+  [Integer, BuiltinByteString, BuiltinByteString]
+>;
+
+export class MeshVestingContract extends MeshTxInitiator {
+  scriptCbor = applyParamsToScript(blueprint.validators[0]!.compiledCode, []);
+
+  constructor(inputs: MeshTxInitiatorInput) {
+    super(inputs);
+  }
+
+  depositFund = async (
+    amount: Asset[],
+    lockUntilTimeStampMs: number,
+    beneficiary: string,
+  ): Promise<string> => {
+    const { utxos, walletAddress } = await this.getWalletInfoForTx();
+
+    const scriptAddr = serializePlutusScript(
+      { code: this.scriptCbor, version: "V2" },
+      undefined,
+      0,
+    ).address;
+    const { pubKeyHash: ownerPubKeyHash } = deserializeAddress(walletAddress);
+    const { pubKeyHash: beneficiaryPubKeyHash } =
+      deserializeAddress(beneficiary);
+
+    await this.mesh
+      .txOut(scriptAddr, amount)
+      .txOutInlineDatumValue(
+        mConStr0([
+          lockUntilTimeStampMs,
+          ownerPubKeyHash,
+          beneficiaryPubKeyHash,
+        ]),
+      )
+      .changeAddress(walletAddress)
+      .selectUtxosFrom(utxos)
+      .complete();
+    return this.mesh.txHex;
+  };
+
+  withdrawFund = async (vestingUtxo: UTxO): Promise<string> => {
+    const { utxos, walletAddress, collateral } =
+      await this.getWalletInfoForTx();
+    const { input: collateralInput, output: collateralOutput } = collateral;
+    const scriptAddr = serializePlutusScript(
+      { code: this.scriptCbor, version: "V2" },
+      undefined,
+      0,
+    ).address;
+    const { pubKeyHash } = deserializeAddress(walletAddress);
+
+    const datum = deserializeDatum<VestingDatum>(
+      vestingUtxo.output.plutusData!,
+    );
+
+    const invalidBefore =
+      unixTimeToEnclosingSlot(
+        Math.min(datum.fields[0].int as number, Date.now() - 15000),
+        this.networkId === 0
+          ? SLOT_CONFIG_NETWORK.preprod
+          : SLOT_CONFIG_NETWORK.mainnet,
+      ) + 1;
+
+    await this.mesh
+      .spendingPlutusScriptV2()
+      .txIn(
+        vestingUtxo.input.txHash,
+        vestingUtxo.input.outputIndex,
+        vestingUtxo.output.amount,
+        scriptAddr,
+      )
+      .spendingReferenceTxInInlineDatumPresent()
+      .spendingReferenceTxInRedeemerValue("")
+      .txInScript(this.scriptCbor)
+      .txOut(walletAddress, [])
+      .txInCollateral(
+        collateralInput.txHash,
+        collateralInput.outputIndex,
+        collateralOutput.amount,
+        collateralOutput.address,
+      )
+      .invalidBefore(invalidBefore)
+      .requiredSignerHash(pubKeyHash)
+      .changeAddress(walletAddress)
+      .selectUtxosFrom(utxos)
+      .complete();
+    return this.mesh.txHex;
+  };
+
+  getUtxoByTxHash = async (txHash: string): Promise<UTxO | undefined> => {
+    return await this._getUtxoByTxHash(this.scriptCbor, txHash);
+  };
+}

package/src/vesting/readme.md

@@ -0,0 +1,36 @@
+# Vesting Contract
+
+Vesting contract is a smart contract that locks up funds for a period of time and allows the owner to withdraw the funds after the lockup period.
+
+[Demo](https://meshjs.dev/smart-contracts/vesting)
+
+When a new employee joins an organization, they typically receive a promise of compensation to be disbursed after a specified duration of employment. This arrangement often involves the organization depositing the funds into a vesting contract, with the employee gaining access to the funds upon the completion of a predetermined lockup period. Through the utilization of vesting contracts, organizations establish a mechanism to encourage employee retention by linking financial rewards to tenure.
+
+There are 2 actions (or endpoints) available to interact with this smart contract:
+
+- deposit asset
+- withdraw asset
+
+To initialize the escrow, we need to initialize a provider, MeshTxBuilder and MeshVestingContract.
+
+```
+import { BlockfrostProvider, MeshTxBuilder } from '@meshsdk/core';
+import { MeshVestingContract } from '@meshsdk/contracts';
+import { useWallet } from '@meshsdk/react';
+
+const { connected, wallet } = useWallet();
+
+const blockchainProvider = new BlockfrostProvider(APIKEY);
+
+const meshTxBuilder = new MeshTxBuilder({
+  fetcher: blockchainProvider,
+  submitter: blockchainProvider,
+});
+
+const contract = new MeshVestingContract({
+  mesh: meshTxBuilder,
+  fetcher: blockchainProvider,
+  wallet: wallet,
+  networkId: 0,
+});
+```

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "@meshsdk/typescript-config/base.json",
+  "include": ["src/**/*"],
+  "exclude": ["dist", "node_modules"]
+}