feat: asteria blaze sdk

.gitignore

@@ -12,4 +12,6 @@ target
 **/.env
 
 .mono
-**/.DS_Store
+**/.DS_Store
+
+node_modules/

onchain/src/aiken.toml

@@ -10,5 +10,5 @@ platform = "github"
 
 [[dependencies]]
 name = "aiken-lang/stdlib"
-version = "1.7.0"
+version = "v2.1.0"
 source = "github"

onchain/src/lib/asteria/types.ak

@@ -1,7 +1,8 @@
-use aiken/hash.{Blake2b_224, Hash}
-use aiken/time.{PosixTime}
-use aiken/transaction/credential.{Script}
-use aiken/transaction/value.{AssetName, PolicyId}
+use aiken/crypto.{Blake2b_224, Hash, Script}
+use cardano/assets.{AssetName, PolicyId}
+
+pub type PosixTime =
+  Int
 
 pub type ScriptAddress =
   Hash<Blake2b_224, Script>

onchain/src/lib/asteria/utils.ak

@@ -1,9 +1,7 @@
-use aiken/bytearray.{length, take}
 use aiken/math
-use aiken/transaction/credential.{
-  Address, ScriptCredential, VerificationKeyCredential,
-}
-use aiken/transaction/value.{AssetName}
+use aiken/primitive/bytearray.{length, take}
+use cardano/address.{Address, Script, VerificationKey}
+use cardano/assets.{AssetName}
 
 pub fn has_prefix(prefix: ByteArray, name: AssetName) -> Bool {
   take(name, length(prefix)) == prefix
@@ -19,7 +17,7 @@ pub fn required_fuel(distance: Int, fuel_per_step: Int) -> Int {
 
 pub fn is_script_address(address: Address) -> Bool {
   when address.payment_credential is {
-    VerificationKeyCredential(_) -> False
-    ScriptCredential(_) -> True
+    VerificationKey(_) -> False
+    Script(_) -> True
   }
 }

onchain/src/validators/admin.ak

@@ -0,0 +1,29 @@
+use aiken/collection/dict
+use aiken/collection/list
+use cardano/assets.{PolicyId}
+use cardano/transaction.{OutputReference, Transaction}
+
+pub type Action {
+  Minting
+  Burning
+}
+
+validator admin(outref: OutputReference) {
+  mint(redeemer: Action, policy_id: PolicyId, self: Transaction) {
+    let Transaction { inputs, mint, .. } = self
+    expect [Pair(_asset_name, quantity)] =
+      mint
+        |> assets.tokens(policy_id)
+        |> dict.to_pairs()
+    let is_outref_consumed =
+      list.any(inputs, fn(input) { input.output_reference == outref })
+    when redeemer is {
+      Minting -> is_outref_consumed && (quantity >= 1)?
+      Burning -> quantity < 0
+    }
+  }
+
+  else(_) {
+    fail
+  }
+}

onchain/src/validators/asteria.ak

@@ -1,31 +1,31 @@
-use aiken/dict
-use aiken/list
+use aiken/collection/dict
+use aiken/collection/list
 use aiken/math/rational.{compare_with, from_int}
 use aiken/option
-use aiken/transaction.{
-  InlineDatum, ScriptContext, Spend, Transaction, find_input,
-}
-use aiken/transaction/value.{ada_asset_name, ada_policy_id}
 use asteria/types.{
   AddNewShip, AssetClass, AsteriaDatum, AsteriaRedeemer, ConsumeAsteria, Mine,
 }
 use asteria/utils
+use cardano/assets.{
+  ada_asset_name, ada_policy_id, add, lovelace_of, quantity_of, tokens,
+}
+use cardano/transaction.{InlineDatum, OutputReference, Transaction, find_input}
 
-validator(
+validator asteria(
   admin_token: AssetClass,
   ship_mint_lovelace_fee: Int,
   max_asteria_mining: Int,
 ) {
-  pub fn spend(
-    datum: AsteriaDatum,
+  spend(
+    datum: Option<AsteriaDatum>,
     redeemer: AsteriaRedeemer,
-    ctx: ScriptContext,
-  ) -> Bool {
-    let ScriptContext { transaction, purpose } = ctx
-    let Transaction { inputs, outputs, .. } = transaction
+    utxo: OutputReference,
+    self: Transaction,
+  ) {
+    let Transaction { inputs, outputs, .. } = self
+    expect Some(datum) = datum
     let AsteriaDatum { ship_counter, shipyard_policy } = datum
-    expect Spend(asteria_ref) = purpose
-    expect Some(asteria_input) = find_input(inputs, asteria_ref)
+    expect Some(asteria_input) = find_input(inputs, utxo)
 
     when redeemer is {
       AddNewShip -> {
@@ -38,15 +38,15 @@ validator(
         expect asteria_output_datum: AsteriaDatum = asteria_output_datum
 
         let must_hold_admin_token =
-          value.quantity_of(
+          quantity_of(
             asteria_output.value,
             admin_token.policy,
             admin_token.name,
           ) > 0
         let must_add_fee =
           asteria_output.value == (
             asteria_input.output.value
-              |> value.add(ada_policy_id, ada_asset_name, ship_mint_lovelace_fee)
+              |> add(ada_policy_id, ada_asset_name, ship_mint_lovelace_fee)
           )
         let must_increment_counter =
           asteria_output_datum.ship_counter == ship_counter + 1
@@ -77,15 +77,15 @@ validator(
               inputs,
               fn(input) {
                 list.any(
-                  dict.keys(value.tokens(input.output.value, shipyard_policy)),
+                  dict.keys(tokens(input.output.value, shipyard_policy)),
                   fn(name) { utils.has_prefix("SHIP", name) },
                 )
               },
             ),
           )
         expect Some(percentage) = rational.new(max_asteria_mining, 100)
-        let input_rewards = value.lovelace_of(asteria_input.output.value)
-        let output_rewards = value.lovelace_of(asteria_output.value)
+        let input_rewards = lovelace_of(asteria_input.output.value)
+        let output_rewards = lovelace_of(asteria_output.value)
         let must_respect_max_mining =
           compare_with(
             from_int(output_rewards),
@@ -109,7 +109,7 @@ validator(
           list.find(
             inputs,
             fn(input) {
-              not(utils.is_script_address(input.output.address)) && value.quantity_of(
+              not(utils.is_script_address(input.output.address)) && quantity_of(
                 input.output.value,
                 admin_token.policy,
                 admin_token.name,
@@ -120,4 +120,8 @@ validator(
       }
     }
   }
+
+  else(_) {
+    fail
+  }
 }

onchain/src/validators/deploy.ak

@@ -1,18 +1,24 @@
-use aiken/list
+use aiken/collection/list
 use aiken/option.{is_some}
-use aiken/transaction.{ScriptContext, Transaction}
-use aiken/transaction/value
 use asteria/types.{AssetClass}
 use asteria/utils
+use cardano/assets.{quantity_of}
+use cardano/transaction.{OutputReference, Transaction}
 
-validator(admin_token: AssetClass) {
-  fn spend(_datum: Data, _redeemer: Data, ctx: ScriptContext) -> Bool {
+validator deploy(admin_token: AssetClass) {
+  spend(
+    _datum: Option<Data>,
+    _redeemer: Data,
+    _utxo: OutputReference,
+    self: Transaction,
+  ) {
+    let Transaction { inputs, .. } = self
     let is_admin_token_input =
       is_some(
         list.find(
-          ctx.transaction.inputs,
+          inputs,
           fn(input) {
-            not(utils.is_script_address(input.output.address)) && value.quantity_of(
+            not(utils.is_script_address(input.output.address)) && quantity_of(
               input.output.value,
               admin_token.policy,
               admin_token.name,
@@ -22,4 +28,8 @@ validator(admin_token: AssetClass) {
       )
     is_admin_token_input
   }
+
+  else(_) {
+    fail
+  }
 }

onchain/src/validators/pellet.ak

@@ -1,38 +1,36 @@
-use aiken/dict
-use aiken/list.{filter}
+use aiken/collection/dict
+use aiken/collection/list.{filter}
 use aiken/option
-use aiken/transaction.{
-  InlineDatum, Mint, Output, ScriptContext, Spend, Transaction, find_input,
-}
-use aiken/transaction/credential.{ScriptCredential}
-use aiken/transaction/value.{quantity_of}
 use asteria/types.{
   AssetClass, BurnFuel, ConsumePellet, FuelRedeemer, MintFuel, PelletDatum,
   PelletRedeemer, Provide,
 }
 use asteria/utils
+use cardano/address.{Script}
+use cardano/assets.{PolicyId, quantity_of, tokens}
+use cardano/transaction.{
+  InlineDatum, Output, OutputReference, Transaction, find_input,
+}
 
-validator(admin_token: AssetClass) {
-  pub fn spend(
-    datum: PelletDatum,
+validator pellet(admin_token: AssetClass) {
+  spend(
+    datum: Option<PelletDatum>,
     redeemer: PelletRedeemer,
-    ctx: ScriptContext,
-  ) -> Bool {
-    let ScriptContext { transaction, purpose } = ctx
-    let Transaction { inputs, outputs, .. } = transaction
+    utxo: OutputReference,
+    self: Transaction,
+  ) {
+    let Transaction { inputs, outputs, .. } = self
 
-    expect Spend(pellet_ref) = purpose
-    expect Some(pellet_input) = find_input(inputs, pellet_ref)
-    expect ScriptCredential(fuel_policy) =
-      pellet_input.output.address.payment_credential
+    expect Some(pellet_input) = find_input(inputs, utxo)
+    expect Script(fuel_policy) = pellet_input.output.address.payment_credential
 
     let remaining_fuel =
       quantity_of(pellet_input.output.value, fuel_policy, "FUEL")
 
     when redeemer is {
       Provide(provided_amount) -> {
+        expect Some(datum) = datum
         let PelletDatum { shipyard_policy, .. } = datum
-
         expect [pellet_output] =
           filter(
             outputs,
@@ -48,7 +46,7 @@ validator(admin_token: AssetClass) {
               inputs,
               fn(input) {
                 list.any(
-                  dict.keys(value.tokens(input.output.value, shipyard_policy)),
+                  dict.keys(tokens(input.output.value, shipyard_policy)),
                   fn(name) { utils.has_prefix("SHIP", name) },
                 )
               },
@@ -77,7 +75,7 @@ validator(admin_token: AssetClass) {
           list.find(
             inputs,
             fn(input) {
-              not(utils.is_script_address(input.output.address)) && value.quantity_of(
+              not(utils.is_script_address(input.output.address)) && quantity_of(
                 input.output.value,
                 admin_token.policy,
                 admin_token.name,
@@ -90,13 +88,9 @@ validator(admin_token: AssetClass) {
     }
   }
 
-  pub fn mint(redeemer: FuelRedeemer, ctx: ScriptContext) -> Bool {
-    let ScriptContext { transaction, purpose } = ctx
-    let Transaction { inputs, mint, .. } = transaction
-    expect Mint(fuel_policy) = purpose
-    let minted_value =
-      mint
-        |> value.from_minted_value
+  mint(redeemer: FuelRedeemer, fuel_policy: PolicyId, self: Transaction) {
+    let Transaction { inputs, mint, .. } = self
+    let minted_value = mint
 
     when redeemer is {
       MintFuel -> {
@@ -105,7 +99,7 @@ validator(admin_token: AssetClass) {
           list.find(
             inputs,
             fn(input) {
-              value.quantity_of(
+              quantity_of(
                 input.output.value,
                 admin_token.policy,
                 admin_token.name,
@@ -126,4 +120,8 @@ validator(admin_token: AssetClass) {
       }
     }
   }
+
+  else(_) {
+    fail
+  }
 }