@meshsdk/contract 1.6.0-alpha.11

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

@@ -0,0 +1,208 @@
+{
+  "preamble": {
+    "title": "meshjs/swap",
+    "description": "Aiken contracts for project 'meshjs/swap'",
+    "version": "0.0.0",
+    "plutusVersion": "v2",
+    "compiler": {
+      "name": "Aiken",
+      "version": "v1.0.24-alpha+982eff4"
+    },
+    "license": "Apache-2.0"
+  },
+  "validators": [
+    {
+      "title": "swap.swap",
+      "datum": {
+        "title": "datum",
+        "schema": {
+          "$ref": "#/definitions/swap~1SwapDatum"
+        }
+      },
+      "redeemer": {
+        "title": "redeemer",
+        "schema": {
+          "$ref": "#/definitions/swap~1SwapRedeemer"
+        }
+      },
+      "compiledCode": "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",
+      "hash": "3f1869e426f5350c595ffd8ca4a6fba8186947ae0cd6c136fe23054a"
+    }
+  ],
+  "definitions": {
+    "ByteArray": {
+      "dataType": "bytes"
+    },
+    "Int": {
+      "dataType": "integer"
+    },
+    "Option$aiken/transaction/credential/Referenced$aiken/transaction/credential/Credential": {
+      "title": "Optional",
+      "anyOf": [
+        {
+          "title": "Some",
+          "description": "An optional value.",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "$ref": "#/definitions/aiken~1transaction~1credential~1Referenced$aiken~1transaction~1credential~1Credential"
+            }
+          ]
+        },
+        {
+          "title": "None",
+          "description": "Nothing.",
+          "dataType": "constructor",
+          "index": 1,
+          "fields": []
+        }
+      ]
+    },
+    "aiken/dict/Dict$ByteArray_Int": {
+      "title": "Dict",
+      "description": "An opaque `Dict`. The type is opaque because the module maintains some\n invariant, namely: there's only one occurrence of a given key in the dictionary.\n\n Note that the `key` parameter is a phantom-type, and only present as a\n means of documentation. Keys can be any type, yet will need to comparable\n to use functions like `insert`.\n\n See for example:\n\n ```aiken\n pub type Value =\n   Dict<PolicyId, Dict<AssetName, Int>>\n ```",
+      "dataType": "map",
+      "keys": {
+        "$ref": "#/definitions/ByteArray"
+      },
+      "values": {
+        "$ref": "#/definitions/Int"
+      }
+    },
+    "aiken/transaction/credential/Address": {
+      "title": "Address",
+      "description": "A Cardano `Address` typically holding one or two credential references.\n\n Note that legacy bootstrap addresses (a.k.a. 'Byron addresses') are\n completely excluded from Plutus contexts. Thus, from an on-chain\n perspective only exists addresses of type 00, 01, ..., 07 as detailed\n in [CIP-0019 :: Shelley Addresses](https://github.com/cardano-foundation/CIPs/tree/master/CIP-0019/#shelley-addresses).",
+      "anyOf": [
+        {
+          "title": "Address",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "title": "payment_credential",
+              "$ref": "#/definitions/aiken~1transaction~1credential~1Credential"
+            },
+            {
+              "title": "stake_credential",
+              "$ref": "#/definitions/Option$aiken~1transaction~1credential~1Referenced$aiken~1transaction~1credential~1Credential"
+            }
+          ]
+        }
+      ]
+    },
+    "aiken/transaction/credential/Credential": {
+      "title": "Credential",
+      "description": "A general structure for representing an on-chain `Credential`.\n\n Credentials are always one of two kinds: a direct public/private key\n pair, or a script (native or Plutus).",
+      "anyOf": [
+        {
+          "title": "VerificationKeyCredential",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "$ref": "#/definitions/ByteArray"
+            }
+          ]
+        },
+        {
+          "title": "ScriptCredential",
+          "dataType": "constructor",
+          "index": 1,
+          "fields": [
+            {
+              "$ref": "#/definitions/ByteArray"
+            }
+          ]
+        }
+      ]
+    },
+    "aiken/transaction/credential/Referenced$aiken/transaction/credential/Credential": {
+      "title": "Referenced",
+      "description": "Represent a type of object that can be represented either inline (by hash)\n or via a reference (i.e. a pointer to an on-chain location).\n\n This is mainly use for capturing pointers to a stake credential\n registration certificate in the case of so-called pointer addresses.",
+      "anyOf": [
+        {
+          "title": "Inline",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "$ref": "#/definitions/aiken~1transaction~1credential~1Credential"
+            }
+          ]
+        },
+        {
+          "title": "Pointer",
+          "dataType": "constructor",
+          "index": 1,
+          "fields": [
+            {
+              "title": "slot_number",
+              "$ref": "#/definitions/Int"
+            },
+            {
+              "title": "transaction_index",
+              "$ref": "#/definitions/Int"
+            },
+            {
+              "title": "certificate_index",
+              "$ref": "#/definitions/Int"
+            }
+          ]
+        }
+      ]
+    },
+    "aiken/transaction/value/Value": {
+      "title": "Value",
+      "description": "A multi-asset output `Value`. Contains tokens indexed by [PolicyId](#PolicyId) and [AssetName](#AssetName).\n\n This type maintain some invariants by construction; in particular, a `Value` will never contain a\n zero quantity of a particular token.",
+      "dataType": "map",
+      "keys": {
+        "$ref": "#/definitions/ByteArray"
+      },
+      "values": {
+        "$ref": "#/definitions/aiken~1dict~1Dict$ByteArray_Int"
+      }
+    },
+    "swap/SwapDatum": {
+      "title": "SwapDatum",
+      "anyOf": [
+        {
+          "title": "SwapDatum",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": [
+            {
+              "title": "initiator",
+              "$ref": "#/definitions/aiken~1transaction~1credential~1Address"
+            },
+            {
+              "title": "to_provide",
+              "$ref": "#/definitions/aiken~1transaction~1value~1Value"
+            },
+            {
+              "title": "to_receive",
+              "$ref": "#/definitions/aiken~1transaction~1value~1Value"
+            }
+          ]
+        }
+      ]
+    },
+    "swap/SwapRedeemer": {
+      "title": "SwapRedeemer",
+      "anyOf": [
+        {
+          "title": "Cancel",
+          "dataType": "constructor",
+          "index": 0,
+          "fields": []
+        },
+        {
+          "title": "Swap",
+          "dataType": "constructor",
+          "index": 1,
+          "fields": []
+        }
+      ]
+    }
+  }
+}

package/src/swap/aiken-workspace/readme.md

@@ -0,0 +1,55 @@
+# swap
+
+Write validators in the `validators` folder, and supporting functions in the `lib` folder using `.ak` as a file extension.
+
+For example, as `validators/always_true.ak`
+
+```gleam
+validator {
+  fn spend(_datum: Data, _redeemer: Data, _context: Data) -> Bool {
+    True
+  }
+}
+```
+
+## Building
+
+```sh
+aiken build
+```
+
+## Testing
+
+You can write tests in any module using the `test` keyword. For example:
+
+```gleam
+test foo() {
+  1 + 1 == 2
+}
+```
+
+To run all tests, simply do:
+
+```sh
+aiken check
+```
+
+To run only tests matching the string `foo`, do:
+
+```sh
+aiken check -m foo
+```
+
+## Documentation
+
+If you're writing a library, you might want to generate an HTML documentation for it.
+
+Use:
+
+```sh
+aiken docs
+```
+
+## Resources
+
+Find more on the [Aiken's user manual](https://aiken-lang.org).

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

@@ -0,0 +1,188 @@
+use aiken/transaction.{
+  Input, ScriptContext, Spend, Transaction, find_input, placeholder,
+}
+use aiken/transaction/credential.{Address}
+use aiken/transaction/value.{
+  AssetName, PolicyId, from_asset, from_asset_list, from_lovelace,
+}
+use sidan_placeholder/address.{mock_pub_key_address, mock_script_address}
+use sidan_placeholder/builder.{
+  complete, new_tx_tester, tx_in, tx_in_inline_datum, tx_out,
+}
+use sidan_placeholder/key_hex.{mock_pub_key_hex}
+use sidan_placeholder/output_reference.{mock_tx_hash, mock_utxo_ref}
+use sidan_utils/address.{address_pub_key} as sidan_address
+use sidan_utils/extra_signatories.{key_signed}
+use sidan_utils/inputs.{inputs_at}
+use sidan_utils/value.{get_all_value_from,
+  get_all_value_to, value_geq} as sidan_value
+
+pub type MValue =
+  Pairs<PolicyId, Pairs<AssetName, Int>>
+
+pub type SwapDatum {
+  SwapDatum { initiator: Address, to_provide: MValue, to_receive: MValue }
+}
+
+pub type SwapRedeemer {
+  Cancel
+  Swap
+}
+
+validator {
+  fn swap(datum: SwapDatum, redeemer: SwapRedeemer, ctx: ScriptContext) {
+    when ctx.purpose is {
+      Spend(utxo) ->
+        when redeemer is {
+          Swap -> {
+            expect Some(own_input) = find_input(ctx.transaction.inputs, utxo)
+            let own_address = own_input.output.address
+            let inputs_from_script =
+              inputs_at(ctx.transaction.inputs, own_address)
+            let is_only_one_input_from_script =
+              when inputs_from_script is {
+                [_] -> True
+                _ -> False
+              }
+
+            let is_proceed_paid =
+              get_all_value_to(ctx.transaction.outputs, datum.initiator)
+                |> value_geq(datum.to_receive |> from_asset_list())
+            let is_token_unlocked =
+              get_all_value_from(inputs_from_script, own_address)
+                |> value_geq(datum.to_provide |> from_asset_list())
+            is_only_one_input_from_script && is_token_unlocked && is_proceed_paid
+          }
+          Cancel -> {
+            expect Some(pub_key) = address_pub_key(datum.initiator)
+            key_signed(ctx.transaction.extra_signatories, pub_key)
+          }
+        }
+      _ -> False
+    }
+  }
+}
+
+type SwapTestCase {
+  is_only_one_input_from_script: Bool,
+  is_token_unlocked: Bool,
+  is_proceed_paid: Bool,
+}
+
+fn get_swap_test_tx(test_case: SwapTestCase) {
+  let SwapTestCase {
+    is_only_one_input_from_script,
+    is_token_unlocked,
+    is_proceed_paid,
+  } = test_case
+
+  new_tx_tester()
+    |> tx_in(
+        True,
+        mock_tx_hash(1),
+        1,
+        from_lovelace(
+          if is_token_unlocked {
+            15_000_000
+          } else {
+            10_000_000
+          },
+        ),
+        mock_script_address(1, None),
+      )
+    |> tx_in_inline_datum(True, swap_datum())
+    |> tx_in(
+        !is_only_one_input_from_script,
+        mock_tx_hash(1),
+        1,
+        from_lovelace(10_000_000),
+        mock_script_address(1, None),
+      )
+    |> tx_in_inline_datum(!is_only_one_input_from_script, swap_datum())
+    |> tx_out(
+        is_proceed_paid,
+        mock_pub_key_address(1, None),
+        from_asset("test", "test", 1_000),
+      )
+    |> complete()
+}
+
+fn swap_datum() -> SwapDatum {
+  SwapDatum {
+    initiator: mock_pub_key_address(1, None),
+    to_provide: [Pair("", [Pair("", 15_000_000)])],
+    to_receive: [Pair("test", [Pair("test", 1_000)])],
+  }
+}
+
+test success_swapping() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let test_case =
+    SwapTestCase {
+      is_only_one_input_from_script: True,
+      is_token_unlocked: True,
+      is_proceed_paid: True,
+    }
+
+  let tx = get_swap_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  swap(swap_datum(), Swap, ctx)
+}
+
+test fail_swapping_attempting_double_satisfaction() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let test_case =
+    SwapTestCase {
+      is_only_one_input_from_script: False,
+      is_token_unlocked: True,
+      is_proceed_paid: True,
+    }
+
+  let tx = get_swap_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !swap(swap_datum(), Swap, ctx)
+}
+
+test fail_swapping_without_sufficient_proceed() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let test_case =
+    SwapTestCase {
+      is_only_one_input_from_script: True,
+      is_token_unlocked: False,
+      is_proceed_paid: True,
+    }
+
+  let tx = get_swap_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !swap(swap_datum(), Swap, ctx)
+}
+
+test fail_swapping_without_proceed_paid() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let test_case =
+    SwapTestCase {
+      is_only_one_input_from_script: True,
+      is_token_unlocked: True,
+      is_proceed_paid: False,
+    }
+
+  let tx = get_swap_test_tx(test_case)
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !swap(swap_datum(), Swap, ctx)
+}
+
+test success_cancel() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let tx =
+    Transaction { ..placeholder(), extra_signatories: [mock_pub_key_hex(1)] }
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  swap(swap_datum(), Cancel, ctx)
+}
+
+test fail_cancel_without_key() {
+  let output_reference = mock_utxo_ref(1, 1)
+  let tx =
+    Transaction { ..placeholder(), extra_signatories: [mock_pub_key_hex(2)] }
+  let ctx = ScriptContext { purpose: Spend(output_reference), transaction: tx }
+  !swap(swap_datum(), Cancel, ctx)
+}

package/src/swap/index.ts

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

package/src/swap/offchain.ts

@@ -0,0 +1,139 @@
+import {
+  Asset,
+  conStr0,
+  ConStr0,
+  mConStr0,
+  mConStr1,
+  parsePlutusValueToAssets,
+  pubKeyAddress,
+  PubKeyAddress,
+  UTxO,
+  value,
+  Value,
+} from "@meshsdk/common";
+import {
+  deserializeAddress,
+  deserializeDatum,
+  serializeAddressObj,
+  serializePlutusScript,
+} from "@meshsdk/core";
+import { applyParamsToScript } from "@meshsdk/core-csl";
+
+import { MeshTxInitiator, MeshTxInitiatorInput } from "../common";
+import blueprint from "./aiken-workspace/plutus.json";
+
+export const MeshSwapBlueprint = blueprint;
+
+export type SwapDatum = ConStr0<[PubKeyAddress, Value, Value]>;
+
+export class MeshSwapContract extends MeshTxInitiator {
+  scriptCbor = applyParamsToScript(blueprint.validators[0]!.compiledCode, []);
+  scriptAddress: string;
+
+  constructor(inputs: MeshTxInitiatorInput) {
+    super(inputs);
+    this.scriptAddress = serializePlutusScript(
+      { code: this.scriptCbor, version: "V2" },
+      undefined,
+      0,
+    ).address;
+  }
+
+  initiateSwap = async (
+    toProvide: Asset[],
+    toReceive: Asset[],
+  ): Promise<string> => {
+    const { utxos, walletAddress, collateral } =
+      await this.getWalletInfoForTx();
+    const { pubKeyHash, stakeCredentialHash } =
+      deserializeAddress(walletAddress);
+    const swapDatum: SwapDatum = conStr0([
+      pubKeyAddress(pubKeyHash, stakeCredentialHash),
+      value(toProvide),
+      value(toReceive),
+    ]);
+
+    await this.mesh
+      .txOut(this.scriptAddress, toProvide)
+      .txOutInlineDatumValue(swapDatum, "JSON")
+      .changeAddress(walletAddress)
+      .txInCollateral(
+        collateral.input.txHash,
+        collateral.input.outputIndex,
+        collateral.output.amount,
+        collateral.output.address,
+      )
+      .selectUtxosFrom(utxos)
+      .complete();
+
+    return this.mesh.txHex;
+  };
+
+  acceptSwap = async (swapUtxo: UTxO): Promise<string> => {
+    const { utxos, walletAddress, collateral } =
+      await this.getWalletInfoForTx();
+    const inlineDatum = deserializeDatum<SwapDatum>(
+      swapUtxo.output.plutusData!,
+    );
+    const initiatorAddress = serializeAddressObj(inlineDatum.fields[0]);
+    const initiatorToReceive = inlineDatum.fields[2];
+
+    await this.mesh
+      .spendingPlutusScriptV2()
+      .txIn(
+        swapUtxo.input.txHash,
+        swapUtxo.input.outputIndex,
+        swapUtxo.output.amount,
+        swapUtxo.output.address,
+      )
+      .spendingReferenceTxInInlineDatumPresent()
+      .spendingReferenceTxInRedeemerValue(mConStr1([]))
+      .txInScript(this.scriptCbor)
+      .txOut(initiatorAddress, parsePlutusValueToAssets(initiatorToReceive))
+      .changeAddress(walletAddress)
+      .txInCollateral(
+        collateral.input.txHash,
+        collateral.input.outputIndex,
+        collateral.output.amount,
+        collateral.output.address,
+      )
+      .selectUtxosFrom(utxos)
+      .complete();
+    return this.mesh.txHex;
+  };
+
+  cancelSwap = async (swapUtxo: UTxO): Promise<string> => {
+    const { utxos, walletAddress, collateral } =
+      await this.getWalletInfoForTx();
+    const inlineDatum = deserializeDatum<SwapDatum>(
+      swapUtxo.output.plutusData!,
+    );
+    const initiatorAddress = serializeAddressObj(inlineDatum.fields[0]);
+    await this.mesh
+      .spendingPlutusScriptV2()
+      .txIn(
+        swapUtxo.input.txHash,
+        swapUtxo.input.outputIndex,
+        swapUtxo.output.amount,
+        swapUtxo.output.address,
+      )
+      .spendingReferenceTxInInlineDatumPresent()
+      .spendingReferenceTxInRedeemerValue(mConStr0([]))
+      .txInScript(this.scriptCbor)
+      .changeAddress(walletAddress)
+      .txInCollateral(
+        collateral.input.txHash,
+        collateral.input.outputIndex,
+        collateral.output.amount,
+        collateral.output.address,
+      )
+      .requiredSignerHash(deserializeAddress(initiatorAddress).pubKeyHash)
+      .selectUtxosFrom(utxos)
+      .complete();
+    return this.mesh.txHex;
+  };
+
+  getUtxoByTxHash = async (txHash: string): Promise<UTxO | undefined> => {
+    return await this._getUtxoByTxHash(this.scriptCbor, txHash);
+  };
+}

package/src/swap/readme.md

@@ -0,0 +1,35 @@
+# Swap
+
+Swap contract facilitates the exchange of assets between two parties. This contract is designed to be used in a peer-to-peer exchange scenario where two parties agree to exchange assets. The contract ensures that the assets are locked up until it is accepted by the other party. At any point before it is accepted, one can cancel the swap to retrieve the assets.
+
+[Demo](https://meshjs.dev/smart-contracts/swap)
+
+There are 2 actions (or endpoints) available to interact with this smart contract:
+
+- initiate swap
+- accept asset
+- cancel swap
+
+To initialize the swap, we need to initialize a provider, MeshTxBuilder and MeshSwapContract.
+
+```typescript
+import { BlockfrostProvider, MeshTxBuilder } from '@meshsdk/core';
+import { MeshSwapContract } 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 MeshSwapContract({
+  mesh: meshTxBuilder,
+  fetcher: blockchainProvider,
+  wallet: wallet,
+  networkId: 0,
+});
+```

package/src/vesting/aiken-workspace/README.md

@@ -0,0 +1,24 @@
+# Vesting - Specification
+
+## Scripts - VestingValidator
+
+The validator of locking vesting value.
+
+### Parameter - no parameter
+
+### Datum
+
+- `lock_until`: POSIX time in second at locking end, e.g. 1672843961000
+- `owner`: Owner's pub key hash
+- `beneficiary`: Beneficiary's pub key hash
+
+### User Action
+
+1. Unlock by owner
+
+   - Signed by `owner`
+
+2. Unlock by beneficiary
+
+   - Signed by `beneficiary`
+   - Only valid after `lock_until`

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

@@ -0,0 +1,26 @@
+# This file was generated by Aiken
+# You typically do not need to edit this file
+
+[[requirements]]
+name = "aiken-lang/stdlib"
+version = "1.9.0"
+source = "github"
+
+[[requirements]]
+name = "sidan-lab/aiken-utils"
+version = "0.1.6-beta"
+source = "github"
+
+[[packages]]
+name = "aiken-lang/stdlib"
+version = "1.9.0"
+requirements = []
+source = "github"
+
+[[packages]]
+name = "sidan-lab/aiken-utils"
+version = "0.1.6-beta"
+requirements = []
+source = "github"
+
+[etags]