Merge remote-tracking branch 'origin/master' into tx-builder-max-output-size-fixes

# Conflicts:
#	rust/src/tx_builder.rs

Author: vsubhuman

.github/workflows/pr-checks.yml

@@ -0,0 +1,35 @@
+name: PR Checks
+
+on:
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  test:
+    if: github.event.review && (github.event.review.state == 'approved' || contains(github.event.review.body, '/check'))
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: 'recursive'
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '12.18.1'
+      - name: Cache node modules
+        uses: actions/cache@v1
+        with:
+          path: ~/.npm # npm cache files are stored in `~/.npm` on Linux/macOS
+          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-build-${{ env.cache-name }}-
+            ${{ runner.os }}-build-
+            ${{ runner.os }}-
+      - name: install
+        run: |
+          npm install
+      - name: rust:test
+        run: |
+          npm run rust:test
+      - name: rust:build-nodejs
+        run: |
+          npm run rust:build-nodejs

package-lock.json

@@ -1,10 +1,11 @@
 {
   "name": "cardano-serialization-lib",
-  "version": "8.0.0",
+  "version": "8.1.0",
   "description": "(De)serialization functions for the Cardano blockchain along with related utility functions",
   "scripts": {
     "rust:build-nodejs": "rimraf ./rust/pkg && cd rust; wasm-pack build --target=nodejs; wasm-pack pack; cd .. && npm run js:flowgen",
     "rust:build-browser": "rimraf ./rust/pkg && cd rust; wasm-pack build --target=browser; wasm-pack pack; cd .. && npm run js:flowgen",
+    "rust:build-web": "rimraf ./rust/pkg && cd rust; wasm-pack build --target=web; wasm-pack pack; cd .. && npm run js:flowgen",
     "rust:build-asm": "rimraf ./rust/pkg && cd rust; wasm-pack build --target=browser --release; wasm-pack pack && npm run asm:build && npm run js:flowgen",
     "rust:publish": "cd rust && cargo publish && cd ../",
     "asm:build": "./binaryen/bin/wasm2js ./rust/pkg/cardano_serialization_lib_bg.wasm --output ./rust/pkg/cardano_serialization_lib.asm.js && node ./scripts/wasm-to-asm",

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "cardano-serialization-lib"
-version = "8.0.0"
+version = "8.1.0"
 edition = "2018"
 authors = ["EMURGO"]
 license = "MIT"

rust/Cargo.lock

@@ -5,13 +5,6 @@
  * @flow
  */
 
-/**
- * @param {Transaction} tx
- * @param {LinearFee} linear_fee
- * @returns {BigNum}
- */
-declare export function min_fee(tx: Transaction, linear_fee: LinearFee): BigNum;
-
 /**
  * @param {string} password
  * @param {string} salt
@@ -36,6 +29,13 @@ declare export function decrypt_with_password(
   data: string
 ): string;
 
+/**
+ * @param {Transaction} tx
+ * @param {LinearFee} linear_fee
+ * @returns {BigNum}
+ */
+declare export function min_fee(tx: Transaction, linear_fee: LinearFee): BigNum;
+
 /**
  * @param {TransactionHash} tx_body_hash
  * @param {ByronAddress} addr
@@ -1242,27 +1242,17 @@ declare export class CostModel {
   static new(): CostModel;
 
   /**
-   * @returns {number}
-   */
-  len(): number;
-
-  /**
-   * @param {string} key
-   * @param {BigInt} value
-   * @returns {BigInt | void}
-   */
-  insert(key: string, value: BigInt): BigInt | void;
-
-  /**
-   * @param {string} key
-   * @returns {BigInt | void}
+   * @param {number} operation
+   * @param {Int} cost
+   * @returns {Int}
    */
-  get(key: string): BigInt | void;
+  set(operation: number, cost: Int): Int;
 
   /**
-   * @returns {Strings}
+   * @param {number} operation
+   * @returns {Int}
    */
-  keys(): Strings;
+  get(operation: number): Int;
 }
 /**
  */

rust/Cargo.toml

@@ -84,32 +84,38 @@ impl ConstrPlutusData {
     const GENERAL_FORM_TAG: u64 = 102;
 }
 
+const COST_MODEL_OP_COUNT: usize = 166;
+
 #[wasm_bindgen]
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
-pub struct CostModel(std::collections::BTreeMap<String, BigInt>);
+pub struct CostModel(Vec<Int>);
 
 to_from_bytes!(CostModel);
 
 #[wasm_bindgen]
 impl CostModel {
     pub fn new() -> Self {
-        Self(std::collections::BTreeMap::new())
-    }
-
-    pub fn len(&self) -> usize {
-        self.0.len()
-    }
-
-    pub fn insert(&mut self, key: String, value: &BigInt) -> Option<BigInt> {
-        self.0.insert(key, value.clone())
+        let mut costs = Vec::with_capacity(COST_MODEL_OP_COUNT);
+        for _ in 0 .. COST_MODEL_OP_COUNT {
+            costs.push(Int::new_i32(0));
+        }
+        Self(costs)
     }
 
-    pub fn get(&self, key: String) -> Option<BigInt> {
-        self.0.get(&key).map(|v| v.clone())
+    pub fn set(&mut self, operation: usize, cost: &Int) -> Result<Int, JsError> {
+        if operation >= COST_MODEL_OP_COUNT {
+            return Err(JsError::from_str(&format!("CostModel operation {} out of bounds. Max is {}", operation, COST_MODEL_OP_COUNT)));
+        }
+        let old = self.0[operation].clone();
+        self.0[operation] = cost.clone();
+        Ok(old)
     }
 
-    pub fn keys(&self) -> Strings {
-        Strings(self.0.iter().map(|(k, _v)| k.clone()).collect::<Vec<_>>())
+    pub fn get(&self, operation: usize) -> Result<Int, JsError> {
+        if operation >= COST_MODEL_OP_COUNT {
+            return Err(JsError::from_str(&format!("CostModel operation {} out of bounds. Max is {}", operation, COST_MODEL_OP_COUNT)));
+        }
+        Ok(self.0[operation].clone())
     }
 }
 
@@ -295,8 +301,6 @@ enum PlutusDataEnum {
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub struct PlutusData(PlutusDataEnum);
 
-const PLUTUS_BYTES_MAX_LEN: usize = 64;
-
 to_from_bytes!(PlutusData);
 
 #[wasm_bindgen]
@@ -317,12 +321,8 @@ impl PlutusData {
         Self(PlutusDataEnum::Integer(integer.clone()))
     }
 
-    pub fn new_bytes(bytes: Vec<u8>) -> Result<PlutusData, JsError> {
-        if bytes.len() > PLUTUS_BYTES_MAX_LEN {
-            Err(JsError::from_str(&format!("Max Plutus bytes too long: {}, max = {}", bytes.len(), PLUTUS_BYTES_MAX_LEN)))
-        } else {
-            Ok(Self(PlutusDataEnum::Bytes(bytes)))
-        }
+    pub fn new_bytes(bytes: Vec<u8>) -> Self {
+        Self(PlutusDataEnum::Bytes(bytes))
     }
 
     pub fn kind(&self) -> PlutusDataKind {
@@ -628,34 +628,36 @@ impl Deserialize for ConstrPlutusData {
 
 impl cbor_event::se::Serialize for CostModel {
     fn serialize<'se, W: Write>(&self, serializer: &'se mut Serializer<W>) -> cbor_event::Result<&'se mut Serializer<W>> {
-        serializer.write_map(cbor_event::Len::Len(self.0.len() as u64))?;
-        for (key, value) in &self.0 {
-            serializer.write_text(&key)?;
-            value.serialize(serializer)?;
+        serializer.write_map(cbor_event::Len::Len(COST_MODEL_OP_COUNT as u64))?;
+        for cost in &self.0 {
+            cost.serialize(serializer)?;
         }
         Ok(serializer)
     }
 }
 
 impl Deserialize for CostModel {
     fn deserialize<R: BufRead + Seek>(raw: &mut Deserializer<R>) -> Result<Self, DeserializeError> {
-        let mut table = std::collections::BTreeMap::new();
+        let mut arr = Vec::new();
         (|| -> Result<_, DeserializeError> {
-            let len = raw.map()?;
-            while match len { cbor_event::Len::Len(n) => table.len() < n as usize, cbor_event::Len::Indefinite => true, } {
+            let len = raw.array()?;
+            while match len { cbor_event::Len::Len(n) => arr.len() < n as usize, cbor_event::Len::Indefinite => true, } {
                 if raw.cbor_type()? == CBORType::Special {
                     assert_eq!(raw.special()?, CBORSpecial::Break);
                     break;
                 }
-                let key = String::deserialize(raw)?;
-                let value = BigInt::deserialize(raw)?;
-                if table.insert(key.clone(), value).is_some() {
-                    return Err(DeserializeFailure::DuplicateKey(Key::Str(key)).into());
-                }
+                arr.push(Int::deserialize(raw)?);
+            }
+            if arr.len() != COST_MODEL_OP_COUNT {
+                return Err(DeserializeFailure::OutOfRange{
+                    min: COST_MODEL_OP_COUNT,
+                    max: COST_MODEL_OP_COUNT,
+                    found: arr.len()
+                }.into());
             }
             Ok(())
         })().map_err(|e| e.annotate("CostModel"))?;
-        Ok(Self(table))
+        Ok(Self(arr.try_into().unwrap()))
     }
 }
 
@@ -862,7 +864,7 @@ impl cbor_event::se::Serialize for PlutusDataEnum {
                 x.serialize(serializer)
             },
             PlutusDataEnum::Bytes(x) => {
-                serializer.write_bytes(&x)
+                write_bounded_bytes(serializer, &x)
             },
         }
     }
@@ -901,18 +903,10 @@ impl Deserialize for PlutusDataEnum {
                 Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),
             };
             match (|raw: &mut Deserializer<_>| -> Result<_, DeserializeError> {
-                Ok(raw.bytes()?)
+                Ok(read_bounded_bytes(raw)?)
             })(raw)
             {
-                Ok(variant) => if variant.len() <= PLUTUS_BYTES_MAX_LEN {
-                    return Ok(PlutusDataEnum::Bytes(variant));
-                } else {
-                    return Err(DeserializeFailure::OutOfRange{
-                        min: 0,
-                        max: PLUTUS_BYTES_MAX_LEN,
-                        found: variant.len(),
-                    }.into());
-                }
+                Ok(variant) => return Ok(PlutusDataEnum::Bytes(variant)),
                 Err(_) => raw.as_mut_ref().seek(SeekFrom::Start(initial_position)).unwrap(),
             };
             Err(DeserializeError::new("PlutusDataEnum", DeserializeFailure::NoVariantMatched.into()))

rust/pkg/cardano_serialization_lib.js.flow

@@ -428,7 +428,7 @@ impl TransactionBuilder {
                             // you would need to have a very high amoun of assets (which add 1-36 bytes each)
                             // in a single policy to make a difference. In the future if this becomes an issue
                             // we can change that here.
-                            
+
                             // this is the other part of the optimization but we need to take into account
                             // the difference between CBOR encoding which can change which happens in two places:
                             // a) length within assets of one policy id
@@ -1333,6 +1333,67 @@ mod tests {
         let _final_tx = tx_builder.build(); // just test that it doesn't throw
     }
 
+    #[test]
+    fn build_tx_no_useless_multiasset() {
+        let linear_fee = LinearFee::new(&to_bignum(44), &to_bignum(155381));
+        let mut tx_builder =
+            TransactionBuilder::new(&linear_fee, &to_bignum(1000000), &to_bignum(500000000), &to_bignum(2000000));
+
+        let policy_id = &PolicyID::from([0u8; 28]);
+        let name = AssetName::new(vec![0u8, 1, 2, 3]).unwrap();
+
+        // add an output that uses up all the token but leaves ADA
+        let mut input_amount = Value::new(&to_bignum(5_000_000));
+        let mut input_multiasset = MultiAsset::new();
+        input_multiasset.insert(policy_id, &{
+            let mut assets = Assets::new();
+            assets.insert(&name, &to_bignum(100));
+            assets
+        });
+        input_amount.set_multiasset(&input_multiasset);
+
+        tx_builder.add_input(
+            &ByronAddress::from_base58("Ae2tdPwUPEZ5uzkzh1o2DHECiUi3iugvnnKHRisPgRRP3CTF4KCMvy54Xd3").unwrap().to_address(),
+            &TransactionInput::new(
+                &genesis_id(),
+                0
+            ),
+            &input_amount
+        );
+
+        // add an input that contains an asset & ADA
+        let mut output_amount = Value::new(&to_bignum(2_000_000));
+        let mut output_multiasset = MultiAsset::new();
+        output_multiasset.insert(policy_id, &{
+            let mut assets = Assets::new();
+            assets.insert(&name, &to_bignum(100));
+            assets
+        });
+        output_amount.set_multiasset(&output_multiasset);
+
+        let output_addr = ByronAddress::from_base58("Ae2tdPwUPEZD9QQf2ZrcYV34pYJwxK4vqXaF8EXkup1eYH73zUScHReM42b").unwrap();
+        tx_builder.add_output(&TransactionOutput::new(
+            &output_addr.to_address(),
+            &output_amount
+        )).unwrap();
+
+        tx_builder.set_ttl(1);
+
+        let change_addr = ByronAddress::from_base58("Ae2tdPwUPEZGUEsuMAhvDcy94LKsZxDjCbgaiBBMgYpR8sKf96xJmit7Eho").unwrap();
+        let added_change = tx_builder.add_change_if_needed(
+            &change_addr.to_address()
+        );
+        assert!(added_change.unwrap());
+        assert_eq!(tx_builder.outputs.len(), 2);
+        let final_tx = tx_builder.build().unwrap();
+        let change_output = final_tx.outputs().get(1);
+        let change_assets = change_output.amount().multiasset();
+
+        // since all tokens got sent in the output
+        // the change should be only ADA and not have any multiasset struct in it
+        assert!(change_assets.is_none());
+    }
+
     #[test]
     fn build_tx_add_change_split_nfts() {
         let linear_fee = LinearFee::new(&to_bignum(0), &to_bignum(1));