Mintable NFT asset id computation in js.

Author: MichaelRiabzev-StarkWare

committee/setup.py

@@ -8,7 +8,7 @@
         'aerospike==3.9.0',
         'aioredis==1.2.0',
         'fastecdsa==1.7.2',
-        'marshmallow-dataclass==6.0.0',
+        'marshmallow-dataclass==7.1.0',
         'marshmallow==3.2.1',
         'PyYAML==5.1',
         'requests == 2.22.0',

crypto/starkware/crypto/signature/asset.js

@@ -23,32 +23,15 @@ const assert = require('assert');
 // Generate BN of 1.
 const oneBn = new BN('1', 16);
 
-// This number is used to shift the packed encoded asset information by 256 bits.
-const shiftBN = new BN('10000000000000000000000000000000000000000000000000000000000000000', 16);
-
 // Used to mask the 251 least signifcant bits given by Keccack256 to produce the final asset ID.
 const mask = new BN('3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16);
 
+// Used to mask the 240 least signifcant bits given by Keccack256 to produce the final asset ID
+// (for mintable assets).
+const mask240 = new BN('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16);
+const maskMintabilityBit =
+    new BN('400000000000000000000000000000000000000000000000000000000000000', 16);
 
-/*
- Computes the hash representing the asset ID for a given asset.
- asset is a dictionary containing the type and data of the asset to parse. the asset type is
- represented by a string describing the associated asset while the data is a dictionary
- containing further infomartion to distinguish between assets of a given type (such as the
- address of the smart contract of an ERC20 asset).
- The function returns the computed asset ID as a hex-string.
-
- For example:
-
-    assetDict = {
-        type: 'ERC20',
-        data: { quantum: '10000', tokenAddress: '0xdAC17F958D2ee523a2206206994597C13D831ec7' }
-    }
-
- Will produce an the following asset ID:
-
-    '0x352386d5b7c781d47ecd404765307d74edc4d43b0490b8e03c71ac7a7429653'.
-*/
 function getAssetType(assetDict) {
     const assetSelector = getAssetSelector(assetDict.type);
 
@@ -64,17 +47,15 @@ function getAssetType(assetDict) {
         // In the case there is a valid tokenAddress in the data, we append that to the asset info
         // (before the quantum).
         const tokenAddress = new BN(encUtils.removeHexPrefix(assetDict.data.tokenAddress), 16);
-        assetInfo = assetInfo.mul(shiftBN);
+        assetInfo = assetInfo.ushln(256).add(tokenAddress);
         expectedLen += 64;
-        assetInfo = assetInfo.add(tokenAddress);
     }
 
     // Default quantum is 1 (for assets which don't specify quantum explicitly).
     const quantInfo = assetDict.data.quantum;
     const quantum = (quantInfo === undefined) ? oneBn : new BN(quantInfo, 10);
-    assetInfo = assetInfo.mul(shiftBN);
+    assetInfo = assetInfo.ushln(256).add(quantum);
     expectedLen += 64;
-    assetInfo = assetInfo.add(quantum);
 
     let assetType = sha3.keccak_256(
         encUtils.hexToBuffer(addLeadingZeroes(assetInfo.toJSON(), expectedLen))
@@ -85,23 +66,64 @@ function getAssetType(assetDict) {
     return '0x' + assetType.toJSON();
 }
 
+/*
+ Computes the hash representing the encoded asset ID for a given asset.
+ asset is a dictionary containing the type and data of the asset to parse. the asset type is
+ represented by a string describing the associated asset while the data is a dictionary
+ containing further information to distinguish between assets of a given type (such as the
+ address of the smart contract of an ERC20 asset).
+ The function returns the computed asset ID as a hex-string.
+
+ For example:
+
+    assetDict = {
+        type: 'ERC20',
+        data: { quantum: '10000', tokenAddress: '0xdAC17F958D2ee523a2206206994597C13D831ec7' }
+    }
+
+ Will produce an the following asset ID:
+
+    '0x352386d5b7c781d47ecd404765307d74edc4d43b0490b8e03c71ac7a7429653'.
+*/
 function getAssetId(assetDict) {
     const assetType = new BN(encUtils.removeHexPrefix(getAssetType(assetDict)), 16);
     // For ETH and ERC20, the asset ID is simply the asset type.
     let assetId = assetType;
     if (assetDict.type === 'ERC721') {
         // ERC721 assets require a slightly different construction for asset info.
         let assetInfo = new BN(encUtils.utf8ToBuffer('NFT:'), 16);
-        assetInfo = assetInfo.mul(shiftBN);
-        assetInfo = assetInfo.add(assetType);
-        assetInfo = assetInfo.mul(shiftBN);
-        assetInfo = assetInfo.add(new BN(parseInt(assetDict.data.tokenId), 16));
-        const expectedLen = 136;
+        // ExpectedLen is equal to the length (in hex characters) of the appended strings:
+        //   'NFT:' (8 characters), 'assetType' (64 characters), 'tokenId' (64 characters).
+        // Where assetType and tokenId are each padded with 0's to account for 64 hex characters
+        // each.
+        // We use this in order to pad the final assetInfo string with leading zeros in case the
+        // calculation discarded them in the process.
+        const expectedLen = 8 + 64 + 64;
+        assetInfo = assetInfo.ushln(256).add(assetType);
+        assetInfo = assetInfo.ushln(256).add(new BN(parseInt(assetDict.data.tokenId), 16));
         assetId = sha3.keccak_256(
             encUtils.hexToBuffer(addLeadingZeroes(assetInfo.toJSON(), expectedLen))
         );
         assetId = new BN(assetId, 16);
         assetId = assetId.and(mask);
+    } else if (assetDict.type === 'MINTABLE_ERC721' || assetDict.type === 'MINTABLE_ERC20') {
+        let assetInfo = new BN(encUtils.utf8ToBuffer('MINTABLE:'), 16);
+        // ExpectedLen is equal to the length (in hex characters) of the appended strings:
+        //   'MINTABLE:' (18 characters), 'assetType' (64 characters), 'blobHash' (64 characters).
+        // Where assetType and blobHash are each padded with 0's to account for 64 hex characters
+        // each.
+        // We use this in order to pad the final assetInfo string with leading zeros in case the
+        // calculation discarded them in the process.
+        const expectedLen = 18 + 64 + 64;
+        assetInfo = assetInfo.ushln(256).add(assetType);
+        const blobHash = blobToBlobHash(assetDict.data.blob);
+        assetInfo = assetInfo.ushln(256).add(new BN(encUtils.removeHexPrefix(blobHash), 16));
+        assetId = sha3.keccak_256(
+            encUtils.hexToBuffer(addLeadingZeroes(assetInfo.toJSON(), expectedLen))
+        );
+        assetId = new BN(assetId, 16);
+        assetId = assetId.and(mask240);
+        assetId = assetId.or(maskMintabilityBit);
     }
 
     return '0x' + assetId.toJSON();
@@ -122,6 +144,12 @@ function getAssetSelector(assetDictType) {
         case 'ERC721':
             seed = 'ERC721Token(address,uint256)';
             break;
+        case 'MINTABLE_ERC20':
+            seed = 'MintableERC20Token(address)';
+            break;
+        case 'MINTABLE_ERC721':
+            seed = 'MintableERC721Token(address,uint256)';
+            break;
         default:
             throw new Error(`Unknown token type: ${assetDictType}`);
     }
@@ -140,6 +168,11 @@ function addLeadingZeroes(hexStr, expectedLen) {
     return res;
 }
 
+function blobToBlobHash(blob) {
+    return '0x' + sha3.keccak_256(blob);
+}
+
+
 module.exports = {
     getAssetType,
     getAssetId  // Function.