Merge pull request #9 from Anastasia-Labs/develop

fix: bump stdlib version
Anastasia-Labs · Oct 22, 2024 · 8e5c1f7 · 8e5c1f7
2 parents 1426440 + 1af45f9
commit 8e5c1f7
Show file tree

Hide file tree

Showing 11 changed files with 47 additions and 82 deletions.
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
@@ -11,9 +11,9 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - uses: aiken-lang/setup-aiken@v0.1.0
+      - uses: aiken-lang/setup-aiken@v1.0.2
         with:
-          version: v1.0.26-alpha
+          version: v1.0.29-alpha
 
       - run: aiken fmt --check
       - run: aiken check -D

diff --git a/aiken.toml b/aiken.toml
@@ -10,7 +10,7 @@ platform = "github"
 
 [[dependencies]]
 name = "aiken-lang/stdlib"
-version = "1.7.0"
+version = "1.9.0"
 source = "github"
 
 [[dependencies]]

diff --git a/lib/aiken-design-patterns/merkelized-validator.ak b/lib/aiken-design-patterns/merkelized-validator.ak
@@ -1,5 +1,5 @@
-use aiken/dict.{Dict}
 use aiken/hash.{Blake2b_224, Hash}
+use aiken/pairs
 use aiken/transaction.{Redeemer, ScriptContext, ScriptPurpose, WithdrawFrom}
 use aiken/transaction/credential.{Inline, Script, ScriptCredential}
 
@@ -11,11 +11,11 @@ pub type WithdrawRedeemer<a, b> {
 pub fn spend(
   staking_validator: Hash<Blake2b_224, Script>,
   function_args: List<Data>,
-  redeemers: Dict<ScriptPurpose, Redeemer>,
+  redeemers: Pairs<ScriptPurpose, Redeemer>,
 ) -> List<Data> {
   expect Some(rdmr) =
     redeemers
-      |> dict.get(WithdrawFrom(Inline(ScriptCredential(staking_validator))))
+      |> pairs.get_first(WithdrawFrom(Inline(ScriptCredential(staking_validator))))
   expect WithdrawRedeemer { input_args, results }: WithdrawRedeemer<Data, Data> =
     rdmr
 

diff --git a/lib/aiken-design-patterns/stake-validator.ak b/lib/aiken-design-patterns/stake-validator.ak
@@ -1,5 +1,5 @@
-use aiken/dict
 use aiken/hash.{Blake2b_224, Hash}
+use aiken/pairs
 use aiken/transaction.{
   Output, Redeemer, ScriptContext, Spend, Transaction, WithdrawFrom,
 }
@@ -17,7 +17,7 @@ pub fn spend(ctx: ScriptContext) -> Bool {
   let own_withdrawal = Inline(own_addr.payment_credential)
 
   // Arbitrary withdrawal from this script is required.
-  dict.has_key(withdrawals, own_withdrawal)
+  pairs.has_key(withdrawals, own_withdrawal)
 }
 
 pub fn withdraw(

diff --git a/validators/merkelized-validator-example.ak b/validators/merkelized-validator-example.ak
@@ -2,10 +2,7 @@ use aiken/dict
 use aiken/fuzz
 use aiken/hash.{Blake2b_224, Hash}
 use aiken/interval
-use aiken/transaction.{
-  Redeemer, ScriptContext, ScriptPurpose, Transaction, TransactionId,
-  WithdrawFrom,
-}
+use aiken/transaction.{ScriptContext, Transaction, TransactionId, WithdrawFrom}
 use aiken/transaction/credential.{Inline, Script, ScriptCredential}
 use aiken/transaction/value
 use aiken_design_patterns/merkelized_validator.{WithdrawRedeemer} as merkelized_validator
@@ -36,13 +33,8 @@ test spend_validator() {
   let stake_validator: Hash<Blake2b_224, Script> =
     #"99999999999999999999999999999999999999999999999999999999"
   let redeemer: Data = WithdrawRedeemer { input_args: [2, 4], results: [20] }
-  let redeemers: dict.Dict<ScriptPurpose, Redeemer> =
-    dict.new()
-      |> dict.insert(
-          WithdrawFrom(Inline(ScriptCredential(stake_validator))),
-          redeemer,
-          fn(_, _) -> Ordering { Less },
-        )
+  let redeemers =
+    [Pair(WithdrawFrom(Inline(ScriptCredential(stake_validator))), redeemer)]
   let tx =
     Transaction {
       inputs: [],
@@ -51,7 +43,7 @@ test spend_validator() {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
       redeemers,
@@ -145,13 +137,8 @@ test prop_spend_validator(r via random_spend_input()) {
   let stake_validator: Hash<Blake2b_224, Script> = r.bs
   let redeemer: Data =
     WithdrawRedeemer { input_args: xs, results: expected_sum_of_squares }
-  let redeemers: dict.Dict<ScriptPurpose, Redeemer> =
-    dict.new()
-      |> dict.insert(
-          WithdrawFrom(Inline(ScriptCredential(stake_validator))),
-          redeemer,
-          fn(_, _) -> Ordering { Less },
-        )
+  let redeemers =
+    [Pair(WithdrawFrom(Inline(ScriptCredential(stake_validator))), redeemer)]
   let tx =
     Transaction {
       inputs: [],
@@ -160,7 +147,7 @@ test prop_spend_validator(r via random_spend_input()) {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
       redeemers,

diff --git a/validators/multi-utxo-indexer-example.ak b/validators/multi-utxo-indexer-example.ak
@@ -63,8 +63,7 @@ test spend_validator() {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(own_val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(own_val_hash)), 1)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -76,7 +75,7 @@ test spend_validator() {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -132,12 +131,7 @@ test prop_spend_validator(r via random_spend_input()) {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(
-          Inline(ScriptCredential(own_val_hash)),
-          r.withdraw_amount,
-          fn(_, _) { Less },
-        )
+    [Pair(Inline(ScriptCredential(own_val_hash)), r.withdraw_amount)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -149,7 +143,7 @@ test prop_spend_validator(r via random_spend_input()) {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -211,8 +205,7 @@ test withdraw_validator() {
   let redeemer =
     [(0, 0)]
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(own_val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(own_val_hash)), 1)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -224,7 +217,7 @@ test withdraw_validator() {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -310,8 +303,7 @@ fn random_withdraw_input() -> Fuzzer<WithdrawInput> {
 test prop_withdraw_validator(r via random_withdraw_input()) {
   let script_purpose = WithdrawFrom(Inline(ScriptCredential(r.val_hash)))
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(r.val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(r.val_hash)), 1)]
   let tx =
     Transaction {
       inputs: r.inputs,
@@ -323,7 +315,7 @@ test prop_withdraw_validator(r via random_withdraw_input()) {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",

diff --git a/validators/multi-utxo-indexer-one-to-many-example.ak b/validators/multi-utxo-indexer-one-to-many-example.ak
@@ -57,8 +57,7 @@ test spend_validator() {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(own_val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(own_val_hash)), 1)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -70,7 +69,7 @@ test spend_validator() {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -126,12 +125,7 @@ test prop_spend_validator(r via random_spend_input()) {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(
-          Inline(ScriptCredential(own_val_hash)),
-          r.withdraw_amount,
-          fn(_, _) { Less },
-        )
+    [Pair(Inline(ScriptCredential(own_val_hash)), r.withdraw_amount)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -143,7 +137,7 @@ test prop_spend_validator(r via random_spend_input()) {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -205,8 +199,7 @@ test withdraw_validator() {
   let redeemer =
     [(0, [0])]
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(own_val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(own_val_hash)), 1)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -218,7 +211,7 @@ test withdraw_validator() {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -304,8 +297,7 @@ fn random_withdraw_input() -> Fuzzer<WithdrawInput> {
 test prop_withdraw_validator(r via random_withdraw_input()) {
   let script_purpose = WithdrawFrom(Inline(ScriptCredential(r.val_hash)))
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(r.val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(r.val_hash)), 1)]
   let tx =
     Transaction {
       inputs: r.inputs,
@@ -317,7 +309,7 @@ test prop_withdraw_validator(r via random_withdraw_input()) {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",

diff --git a/validators/singular-utxo-indexer-example.ak b/validators/singular-utxo-indexer-example.ak
@@ -84,10 +84,10 @@ test spend_validator() {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -169,10 +169,10 @@ test prop_spend_validator(r via random_spend_input()) {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",

diff --git a/validators/singular-utxo-indexer-one-to-many-example.ak b/validators/singular-utxo-indexer-one-to-many-example.ak
@@ -68,10 +68,10 @@ test spend_validator() {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -145,10 +145,10 @@ test prop_spend_validator(r via random_spend_input()) {
       fee: value.zero(),
       mint: value.zero() |> value.to_minted_value(),
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",

diff --git a/validators/stake-validator-example.ak b/validators/stake-validator-example.ak
@@ -50,8 +50,7 @@ test spend_validator() {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(Inline(ScriptCredential(own_val_hash)), 1, fn(_, _) { Less })
+    [Pair(Inline(ScriptCredential(own_val_hash)), 1)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -63,7 +62,7 @@ test spend_validator() {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -115,12 +114,7 @@ test prop_spend_validator(r via random_spend_input()) {
       },
     }
   let withdrawals =
-    dict.new()
-      |> dict.insert(
-          Inline(ScriptCredential(own_val_hash)),
-          r.withdraw_amount,
-          fn(_, _) { Less },
-        )
+    [Pair(Inline(ScriptCredential(own_val_hash)), r.withdraw_amount)]
   let tx =
     Transaction {
       inputs: [input_utxo],
@@ -132,7 +126,7 @@ test prop_spend_validator(r via random_spend_input()) {
       withdrawals,
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",

diff --git a/validators/tx-level-minter-example.ak b/validators/tx-level-minter-example.ak
@@ -58,10 +58,10 @@ test spend_validator() {
       fee: value.zero(),
       mint: minted_value,
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",
@@ -125,10 +125,10 @@ test prop_spend_validator(r via random_spend_input()) {
       fee: value.zero(),
       mint: minted_value,
       certificates: [],
-      withdrawals: dict.new(),
+      withdrawals: [],
       validity_range: interval.everything(),
       extra_signatories: [],
-      redeemers: dict.new(),
+      redeemers: [],
       datums: dict.new(),
       id: TransactionId {
         hash: #"0000000000000000000000000000000000000000000000000000000000000000",