@opcat-labs/cat-sdk 2.0.2 → 2.1.0

package/artifacts/constants.json

@@ -1,12 +1,12 @@
 {
   "version": 10,
   "compilerVersion": "1.21.0+commit.2ada378",
-  "contract": "_opcat_labs_cat_sdk_2_0_2__rs__ConstantsLib",
+  "contract": "_opcat_labs_cat_sdk_2_1_0__rs__ConstantsLib",
   "md5": "d41d8cd98f00b204e9800998ecf8427e",
   "structs": [],
   "library": [
     {
-      "name": "_opcat_labs_cat_sdk_2_0_2__rs__ConstantsLib",
+      "name": "_opcat_labs_cat_sdk_2_1_0__rs__ConstantsLib",
       "params": [],
       "properties": [],
       "genericTypes": []

package/artifacts/constants.scrypt

@@ -1,7 +1,7 @@
 
 
 
-library _opcat_labs_cat_sdk_2_0_2__rs__ConstantsLib {
+library _opcat_labs_cat_sdk_2_1_0__rs__ConstantsLib {
   static const bytes ZERO_SHA1256_HASH = Sha256(b'0000000000000000000000000000000000000000000000000000000000000000');
   static const bytes TOKEN_SCRIPT_HASH_PLACEHOLDER_FF = Sha256(b'00000000000000000000000000000000000000000000000000000000000000ff');
   static const bytes TOKEN_SCRIPT_HASH_PLACEHOLDER_FE = Sha256(b'00000000000000000000000000000000000000000000000000000000000000fe');

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/backtrace.scrypt

@@ -6,33 +6,37 @@ import "stdUtils.scrypt";
 
 
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ChainTxVerifyResponse {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ChainTxVerifyResponse {
   bytes prevPrevScript;
   bytes prevPrevOutpoint;
 }
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__Backtrace {
-  static function checkPrevTxHashPreimage(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage txHashPreimage, bytes t_prevouts, int t_inputIndex) : bool {
-    bytes txHash = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimageUtils.getTxHashFromTxHashPreimage(txHashPreimage);
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Backtrace {
+  static const bytes GENESIS_SCRIPT_HASH = b'8f6157664f8f7cd43e6bba7f3209bb803d4d0fb2fb6e59fdc548989ed3901f15';
+  static function checkPrevTxHashPreimage(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage txHashPreimage, bytes t_prevouts, int t_inputIndex) : bool {
+    bytes txHash = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimageUtils.getTxHashFromTxHashPreimage(txHashPreimage);
     require(txHash == t_prevouts[t_inputIndex * 36 : t_inputIndex * 36 + 32]);
     return true;
   }
-  static function verifyFromOutpoint(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__BacktraceInfo backtraceInfo, bytes t_genesisOutpoint, bytes t_selfScript, bytes t_prevTxInputList) : bool {
-    _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ChainTxVerifyResponse res = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__Backtrace.verifyChainTxs(backtraceInfo, t_prevTxInputList);
+  static function verifyFromOutpoint(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__BacktraceInfo backtraceInfo, bytes t_genesisOutpoint, bytes t_selfScript, bytes t_prevTxInputList) : bool {
+    _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ChainTxVerifyResponse res = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Backtrace.verifyChainTxs(backtraceInfo, t_prevTxInputList);
+    if(res.prevPrevOutpoint == t_genesisOutpoint) {
+        require(res.prevPrevScript == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Backtrace.GENESIS_SCRIPT_HASH);
+      }
     require(res.prevPrevOutpoint == t_genesisOutpoint || res.prevPrevScript == t_selfScript);
     return true;
   }
-  static function verifyFromScript(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__BacktraceInfo backtraceInfo, bytes t_genesisScript, bytes t_selfScript, bytes t_prevTxInputList) : bool {
-    _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ChainTxVerifyResponse res = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__Backtrace.verifyChainTxs(backtraceInfo, t_prevTxInputList);
+  static function verifyFromScript(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__BacktraceInfo backtraceInfo, bytes t_genesisScript, bytes t_selfScript, bytes t_prevTxInputList) : bool {
+    _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ChainTxVerifyResponse res = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Backtrace.verifyChainTxs(backtraceInfo, t_prevTxInputList);
     require(res.prevPrevScript == t_genesisScript || res.prevPrevScript == t_selfScript);
     return true;
   }
-  static function verifyChainTxs(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__BacktraceInfo backtraceInfo, bytes t_prevTxInputList) : _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ChainTxVerifyResponse {
-    require(t_prevTxInputList[backtraceInfo.prevTxInputIndex * 72 : (backtraceInfo.prevTxInputIndex + 1) * 72] == _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.mergeInput(backtraceInfo.prevTxInput));
+  static function verifyChainTxs(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__BacktraceInfo backtraceInfo, bytes t_prevTxInputList) : _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ChainTxVerifyResponse {
+    require(t_prevTxInputList[backtraceInfo.prevTxInputIndex * 72 : (backtraceInfo.prevTxInputIndex + 1) * 72] == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.mergeInput(backtraceInfo.prevTxInput));
     bytes prevPrevTxHash = backtraceInfo.prevTxInput.prevTxHash;
-    require(prevPrevTxHash == _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimageUtils.getTxHashFromTxHashPreimage(backtraceInfo.prevPrevTxPreimage));
+    require(prevPrevTxHash == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimageUtils.getTxHashFromTxHashPreimage(backtraceInfo.prevPrevTxPreimage));
     bytes prevPrevScript = backtraceInfo.prevPrevTxPreimage.outputList[backtraceInfo.prevTxInput.prevOutputIndex * 72 + 8 : (backtraceInfo.prevTxInput.prevOutputIndex) * 72 + 8 + 32];
-    bytes prevPrevOutpoint = prevPrevTxHash + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.uint32ToByteString(backtraceInfo.prevTxInput.prevOutputIndex);
+    bytes prevPrevOutpoint = prevPrevTxHash + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.uint32ToByteString(backtraceInfo.prevTxInput.prevOutputIndex);
     return {prevPrevScript, prevPrevOutpoint};
   }
 }

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/contextUtils.scrypt

@@ -5,7 +5,7 @@ import "stdUtils.scrypt";
 
 
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils {
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils {
   static const PrivKey privKey = PrivKey(0x26f00fe2340a84335ebdf30f57e9bb58487117b29355718f5e46bf5168d7df97);
   static const PubKey pubKey = PubKey(b'02ba79df5f8ae7604a9830f03c7933028186aede0675a16f025dc4f8be8eec0382');
   static const int invK = 0xc8ffdbaa05d93aa4ede79ec58f06a72562048b775a3507c2bf44bde4f007c40a;
@@ -18,7 +18,7 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils {
   static function sign(int h, PrivKey privKey, int inverseK, int r, bytes rBigEndian, bytes sigHashType) : Sig {
     int s = inverseK * (h + r * privKey);
     
-    s = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.normalize(s, 115792089237316195423570985008687907852837564279074904382605163141518161494337);
+    s = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.normalize(s, 115792089237316195423570985008687907852837564279074904382605163141518161494337);
     if(s > 115792089237316195423570985008687907852837564279074904382605163141518161494337 / 2) {
         s = 115792089237316195423570985008687907852837564279074904382605163141518161494337 - s;
       }
@@ -32,13 +32,13 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils {
   static function fromBEUnsigned(bytes b) : int {
     return unpack(reverseBytes(b, 32) + b'00');
   }
-  static function checkSHPreimage(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage shPreimage, bytes sigHashType) : Sig {
-    SigHashPreimage preimage = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.serializeSHPreimage(shPreimage);
+  static function checkSHPreimage(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__SHPreimage shPreimage, bytes sigHashType) : Sig {
+    SigHashPreimage preimage = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.serializeSHPreimage(shPreimage);
     bytes h = hash256(preimage);
-    Sig sig = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.sign(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.fromBEUnsigned(h), _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.privKey, 90914631784428570546048907090666684794265392153046400654824470772421497439242, 7252565254521500021189571868467740368187828957595681190666767817830690399852, _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils.rBigEndian, sigHashType);
+    Sig sig = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.sign(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.fromBEUnsigned(h), _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.privKey, 90914631784428570546048907090666684794265392153046400654824470772421497439242, 7252565254521500021189571868467740368187828957595681190666767817830690399852, _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils.rBigEndian, sigHashType);
     return sig;
   }
-  static function serializeSHPreimage(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage shPreimage) : SigHashPreimage {
+  static function serializeSHPreimage(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__SHPreimage shPreimage) : SigHashPreimage {
     require(len(shPreimage.nVersion) == 4);
     require(len(shPreimage.hashPrevouts) == 32);
     require(len(shPreimage.spentScriptHash) == 32);
@@ -53,41 +53,41 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils {
     require(shPreimage.inputIndex >= 0);
     require(shPreimage.nLockTime >= 0);
     require(shPreimage.sigHashType == 1 || shPreimage.sigHashType == 2 || shPreimage.sigHashType == 3 || shPreimage.sigHashType == 0x81 || shPreimage.sigHashType == 0x82 || shPreimage.sigHashType == 0x83);
-    bytes preimage = shPreimage.nVersion + shPreimage.hashPrevouts + shPreimage.spentScriptHash + shPreimage.spentDataHash + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.satoshisToByteString(shPreimage.value) + shPreimage.nSequence + shPreimage.hashSpentAmounts + shPreimage.hashSpentScriptHashes + shPreimage.hashSpentDataHashes + shPreimage.hashSequences + shPreimage.hashOutputs + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(shPreimage.inputIndex, 4) + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(shPreimage.nLockTime, 4) + num2bin(shPreimage.sigHashType, 4);
+    bytes preimage = shPreimage.nVersion + shPreimage.hashPrevouts + shPreimage.spentScriptHash + shPreimage.spentDataHash + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.satoshisToByteString(shPreimage.value) + shPreimage.nSequence + shPreimage.hashSpentAmounts + shPreimage.hashSpentScriptHashes + shPreimage.hashSpentDataHashes + shPreimage.hashSequences + shPreimage.hashOutputs + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(shPreimage.inputIndex, 4) + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(shPreimage.nLockTime, 4) + num2bin(shPreimage.sigHashType, 4);
     return SigHashPreimage(preimage);
   }
-  static function checkPrevouts(bytes prevouts, bytes t_hashPrevouts, int t_inputIndex, int t_inputCount) : _opcat_labs_scrypt_ts_opcat_2_0_2__rs__Outpoint {
+  static function checkPrevouts(bytes prevouts, bytes t_hashPrevouts, int t_inputIndex, int t_inputCount) : _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Outpoint {
     require(hash256(prevouts) == t_hashPrevouts);
     require(t_inputIndex < t_inputCount);
-    require(t_inputCount == _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(prevouts, 36));
+    require(t_inputCount == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(prevouts, 36));
     bytes b = prevouts[t_inputIndex * 36 : (t_inputIndex + 1) * 36];
-    return {b[0 : 32], _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.byteStringToUInt32(b[32 : 36])};
+    return {b[0 : 32], _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.byteStringToUInt32(b[32 : 36])};
   }
   static function checkSpentScripts(bytes spentScriptHashes, bytes t_hashSpentScripts, int t_inputCount) : bool {
     require(hash256(spentScriptHashes) == t_hashSpentScripts);
-    require(t_inputCount == _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(spentScriptHashes, 32));
+    require(t_inputCount == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(spentScriptHashes, 32));
     return true;
   }
   static function checkSpentAmounts(bytes spentAmounts, bytes hashSpentAmounts) : int {
     require(hash256(spentAmounts) == hashSpentAmounts);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(spentAmounts, 8);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(spentAmounts, 8);
   }
   static function checkSpentDataHashes(bytes spentDataHashes, bytes hashSpentDataHashes, int inputCount) : bool {
     require(hash256(spentDataHashes) == hashSpentDataHashes);
-    require(inputCount == _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(spentDataHashes, 32));
+    require(inputCount == _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(spentDataHashes, 32));
     return true;
   }
   static function getSpentScriptHash(bytes spentScriptHashes, int inputIndex) : bytes {
     return spentScriptHashes[inputIndex * 32 : (inputIndex + 1) * 32];
   }
   static function getSpentAmount(bytes spentAmounts, int inputIndex) : int {
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(spentAmounts[inputIndex * 8 : (inputIndex + 1) * 8]);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(spentAmounts[inputIndex * 8 : (inputIndex + 1) * 8]);
   }
   static function getSpentDataHash(bytes spentDataHashes, int inputIndex) : bytes {
     return spentDataHashes[inputIndex * 32 : (inputIndex + 1) * 32];
   }
-  static function checknLockTime(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage shPreimage, int nlockTime) : bool {
-    int nSequence = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(shPreimage.nSequence);
+  static function checknLockTime(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__SHPreimage shPreimage, int nlockTime) : bool {
+    int nSequence = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(shPreimage.nSequence);
     return (nSequence < 4294967295 && (nlockTime < 500000000 ? shPreimage.nLockTime < 500000000 : true) && shPreimage.nLockTime >= nlockTime);
   }
 }

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/stateUtils.scrypt

@@ -1,7 +1,7 @@
 
 
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StateUtils {
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StateUtils {
   static function checkInputState(int t_inputIndex, bytes stateHash, bytes t_spentDataHashes) : bool {
     require(t_spentDataHashes[t_inputIndex * 32 : (t_inputIndex + 1) * 32] == stateHash);
     return true;

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/stdUtils.scrypt

@@ -1,12 +1,12 @@
 
 
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ReadVarintResult {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ReadVarintResult {
   bytes data;
   int nextPos;
 }
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils {
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils {
   static function checkLenDivisibleBy(bytes b, int n) : int {
     int l = len(b);
     require(l % n == 0);
@@ -14,15 +14,15 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils {
   }
   static function uint64ToByteString(int n) : bytes {
     require(n >= 0 && n <= 18446744073709551615);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(n, 8);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(n, 8);
   }
   static function uint32ToByteString(int n) : bytes {
     require(n >= 0 && n <= 4294967295);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(n, 4);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(n, 4);
   }
   static function byteStringToUInt32(bytes b) : int {
     require(len(b) == 4);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(b);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(b);
   }
   static function toLEUnsigned(int n, int l) : bytes {
     bytes m = num2bin(n, l + 1);
@@ -46,7 +46,7 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils {
         b = b'ff';
         size = 8;
       }
-    return b + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(n, size);
+    return b + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(n, size);
   }
   static function pushData(bytes buf) : bytes {
     int n = len(buf);
@@ -67,27 +67,27 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils {
       } else {
         require(false);
       }
-    return header + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.toLEUnsigned(n, size);
+    return header + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.toLEUnsigned(n, size);
   }
-  static function readVarint(bytes buf, int pos) : _opcat_labs_scrypt_ts_opcat_2_0_2__rs__ReadVarintResult {
+  static function readVarint(bytes buf, int pos) : _opcat_labs_scrypt_ts_opcat_2_1_0__rs__ReadVarintResult {
     int l = 0;
     bytes ret = b'';
     int nextPos = pos;
     bytes header = buf[pos : pos + 1];
     if(header == b'fd') {
-        l = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 3]);
+        l = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 3]);
         ret = buf[3 : 3 + l];
         nextPos = pos + 3 + l;
       } else if(header == b'fe') {
-        l = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 5]);
+        l = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 5]);
         ret = buf[pos + 5 : pos + 5 + l];
         nextPos = pos + 5 + l;
       } else if(header == b'ff') {
-        l = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 9]);
+        l = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(buf[pos + 1 : pos + 9]);
         ret = buf[pos + 9 : pos + 9 + l];
         nextPos = pos + 9 + l;
       } else {
-        l = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(buf[pos : pos + 1]);
+        l = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(buf[pos : pos + 1]);
         ret = buf[pos + 1 : pos + 1 + l];
         nextPos = pos + 1 + l;
       }

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/txHashPreimageUtils.scrypt

@@ -4,17 +4,17 @@ import "stdUtils.scrypt";
 
 
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimageUtils {
-  static function getTxHashFromTxHashPreimage(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage txHashPreimage) : bytes {
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimageUtils {
+  static function getTxHashFromTxHashPreimage(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage txHashPreimage) : bytes {
     require(len(txHashPreimage.version) == 4);
-    int inputCount = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(txHashPreimage.inputList, 72);
-    int outputCount = _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.checkLenDivisibleBy(txHashPreimage.outputList, 72);
-    return hash256(txHashPreimage.version + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.writeVarInt(inputCount) + txHashPreimage.inputList + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.writeVarInt(outputCount) + txHashPreimage.outputList + txHashPreimage.nLockTime);
+    int inputCount = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(txHashPreimage.inputList, 72);
+    int outputCount = _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.checkLenDivisibleBy(txHashPreimage.outputList, 72);
+    return hash256(txHashPreimage.version + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.writeVarInt(inputCount) + txHashPreimage.inputList + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.writeVarInt(outputCount) + txHashPreimage.outputList + txHashPreimage.nLockTime);
   }
-  static function getInputByteString(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage txHashPreimage, int inputIndex) : bytes {
+  static function getInputByteString(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage txHashPreimage, int inputIndex) : bytes {
     return txHashPreimage.inputList[inputIndex * 72 : (inputIndex + 1) * 72];
   }
-  static function getOutputByteString(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage txHashPreimage, int outputIndex) : bytes {
+  static function getOutputByteString(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage txHashPreimage, int outputIndex) : bytes {
     return txHashPreimage.outputList[outputIndex * 72 : (outputIndex + 1) * 72];
   }
 }

package/artifacts/scrypt-ts-opcat/assets/smart-contract/builtin-libs/txUtils.scrypt

@@ -4,10 +4,10 @@ import "stdUtils.scrypt";
 
 
 
-library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils {
+library _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils {
   static const int ZERO_SATS = 0;
   static function buildOutput(bytes scriptHash, int satoshis) : bytes {
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.buildDataOutput(scriptHash, satoshis, sha256(b''));
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.buildDataOutput(scriptHash, satoshis, sha256(b''));
   }
   static function buildDataOutput(bytes scriptHash, int satoshis, bytes dataHash) : bytes {
     int scriptHashLen = len(scriptHash);
@@ -15,34 +15,34 @@ library _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils {
     require(scriptHashLen == 32);
     require(dataHashLen == 32);
     require(satoshis >= 0);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.satoshisToByteString(satoshis) + scriptHash + dataHash;
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.satoshisToByteString(satoshis) + scriptHash + dataHash;
   }
-  static function buildChangeOutput(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxOut change) : bytes {
-    return change.satoshis > 0 ? _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.buildDataOutput(change.scriptHash, change.satoshis, change.dataHash) : b'';
+  static function buildChangeOutput(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxOut change) : bytes {
+    return change.satoshis > 0 ? _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.buildDataOutput(change.scriptHash, change.satoshis, change.dataHash) : b'';
   }
-  static function mergeInput(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxIn txInput) : bytes {
+  static function mergeInput(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxIn txInput) : bytes {
     require(len(txInput.prevTxHash) == 32);
     require(len(txInput.scriptHash) == 32);
-    return (txInput.prevTxHash + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.uint32ToByteString(txInput.prevOutputIndex) + txInput.scriptHash + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.uint32ToByteString(txInput.sequence));
+    return (txInput.prevTxHash + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.uint32ToByteString(txInput.prevOutputIndex) + txInput.scriptHash + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.uint32ToByteString(txInput.sequence));
   }
   static function buildOpReturnOutput(bytes data) : bytes {
     bytes script = b'6a' + pack(len(data)) + data;
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.satoshisToByteString(0) + sha256(script) + sha256(b'');
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.satoshisToByteString(0) + sha256(script) + sha256(b'');
   }
   static function buildP2PKHScript(Ripemd160 addr) : bytes {
     return (OpCode.OP_DUP + OpCode.OP_HASH160 + pack(20) + addr + OpCode.OP_EQUALVERIFY + OpCode.OP_CHECKSIG);
   }
   static function buildP2PKHOutput(int amount, Ripemd160 addr) : bytes {
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.buildDataOutput(sha256(_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils.buildP2PKHScript(addr)), amount, sha256(b''));
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.buildDataOutput(sha256(_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils.buildP2PKHScript(addr)), amount, sha256(b''));
   }
   static function buildOpreturnScript(bytes data) : bytes {
-    return OpCode.OP_FALSE + OpCode.OP_RETURN + _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.pushData(data);
+    return OpCode.OP_FALSE + OpCode.OP_RETURN + _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.pushData(data);
   }
   static function satoshisToByteString(int n) : bytes {
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.uint64ToByteString(n);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.uint64ToByteString(n);
   }
   static function byteStringToSatoshis(bytes bs) : int {
     require(len(bs) == 8);
-    return _opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils.fromLEUnsigned(bs);
+    return _opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils.fromLEUnsigned(bs);
   }
 }

package/artifacts/scrypt-ts-opcat/assets/smart-contract/types/structs.scrypt

@@ -1,33 +1,33 @@
 
 
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxOut {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxOut {
   bytes scriptHash;
   bytes dataHash;
   int satoshis;
 }
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxIn {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxIn {
   bytes prevTxHash;
   int prevOutputIndex;
   int sequence;
   bytes scriptHash;
 }
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage {
   bytes version;
   bytes inputList;
   bytes outputList;
   bytes nLockTime;
 }
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__BacktraceInfo {
-  _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxIn prevTxInput;
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__BacktraceInfo {
+  _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxIn prevTxInput;
   int prevTxInputIndex;
-  _opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage prevPrevTxPreimage;
+  _opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage prevPrevTxPreimage;
 }
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__SHPreimage {
   bytes nVersion;
   bytes hashPrevouts;
   bytes spentScriptHash;
@@ -44,7 +44,7 @@ struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage {
   int sigHashType;
 }
 
-struct _opcat_labs_scrypt_ts_opcat_2_0_2__rs__Outpoint {
+struct _opcat_labs_scrypt_ts_opcat_2_1_0__rs__Outpoint {
   bytes txHash;
   int outputIndex;
 }

package/artifacts/types.json

@@ -5,7 +5,7 @@
   "md5": "d41d8cd98f00b204e9800998ecf8427e",
   "structs": [
     {
-      "name": "_opcat_labs_cat_sdk_2_0_2__rs__CAT20ContractUnlockArgs",
+      "name": "_opcat_labs_cat_sdk_2_1_0__rs__CAT20ContractUnlockArgs",
       "params": [
         {
           "name": "spendType",
@@ -27,7 +27,7 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_cat_sdk_2_0_2__rs__CAT721ContractUnlockArgs",
+      "name": "_opcat_labs_cat_sdk_2_1_0__rs__CAT721ContractUnlockArgs",
       "params": [
         {
           "name": "userPubKey",

package/artifacts/types.scrypt

@@ -1,14 +1,14 @@
 
 
 
-struct _opcat_labs_cat_sdk_2_0_2__rs__CAT20ContractUnlockArgs {
+struct _opcat_labs_cat_sdk_2_1_0__rs__CAT20ContractUnlockArgs {
   int spendType;
   PubKey userPubKey;
   Sig userSig;
   int spendScriptInputIndex;
 }
 
-struct _opcat_labs_cat_sdk_2_0_2__rs__CAT721ContractUnlockArgs {
+struct _opcat_labs_cat_sdk_2_1_0__rs__CAT721ContractUnlockArgs {
   PubKey userPubKey;
   Sig userSig;
   int contractInputIndex;

package/artifacts/utils/ownerUtils.json

@@ -1,11 +1,11 @@
 {
   "version": 10,
   "compilerVersion": "1.21.0+commit.2ada378",
-  "contract": "_opcat_labs_cat_sdk_2_0_2__rs__OwnerUtils",
+  "contract": "_opcat_labs_cat_sdk_2_1_0__rs__OwnerUtils",
   "md5": "d41d8cd98f00b204e9800998ecf8427e",
   "structs": [
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxOut",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxOut",
       "params": [
         {
           "name": "scriptHash",
@@ -23,7 +23,7 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxIn",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxIn",
       "params": [
         {
           "name": "prevTxHash",
@@ -45,7 +45,7 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage",
       "params": [
         {
           "name": "version",
@@ -67,11 +67,11 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__BacktraceInfo",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__BacktraceInfo",
       "params": [
         {
           "name": "prevTxInput",
-          "type": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxIn"
+          "type": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxIn"
         },
         {
           "name": "prevTxInputIndex",
@@ -79,13 +79,13 @@
         },
         {
           "name": "prevPrevTxPreimage",
-          "type": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxHashPreimage"
+          "type": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxHashPreimage"
         }
       ],
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__SHPreimage",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__SHPreimage",
       "params": [
         {
           "name": "nVersion",
@@ -147,7 +147,7 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__Outpoint",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__Outpoint",
       "params": [
         {
           "name": "txHash",
@@ -161,7 +161,7 @@
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__ReadVarintResult",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__ReadVarintResult",
       "params": [
         {
           "name": "data",
@@ -177,25 +177,25 @@
   ],
   "library": [
     {
-      "name": "_opcat_labs_cat_sdk_2_0_2__rs__OwnerUtils",
+      "name": "_opcat_labs_cat_sdk_2_1_0__rs__OwnerUtils",
       "params": [],
       "properties": [],
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__TxUtils",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__TxUtils",
       "params": [],
       "properties": [],
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__ContextUtils",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__ContextUtils",
       "params": [],
       "properties": [],
       "genericTypes": []
     },
     {
-      "name": "_opcat_labs_scrypt_ts_opcat_2_0_2__rs__StdUtils",
+      "name": "_opcat_labs_scrypt_ts_opcat_2_1_0__rs__StdUtils",
       "params": [],
       "properties": [],
       "genericTypes": []

package/artifacts/utils/ownerUtils.scrypt

@@ -4,17 +4,17 @@ import "../scrypt-ts-opcat/assets/smart-contract/builtin-libs/contextUtils.scryp
 
 
 
-library _opcat_labs_cat_sdk_2_0_2__rs__OwnerUtils {
+library _opcat_labs_cat_sdk_2_1_0__rs__OwnerUtils {
   static function pubKeyHashtoLockingScript(bytes pubKeyHash) : bytes {
     require(len(pubKeyHash) == 20);
     return b'76a914' + pubKeyHash + b'88ac';
   }
   static function toLockingScript(bytes pubKey) : bytes {
-    _opcat_labs_cat_sdk_2_0_2__rs__OwnerUtils.checkPubKey(pubKey);
+    _opcat_labs_cat_sdk_2_1_0__rs__OwnerUtils.checkPubKey(pubKey);
     return b'76a914' + hash160(pubKey) + b'88ac';
   }
   static function checkUserOwner(bytes pubKey, bytes ownerAddr) : bool {
-    require(_opcat_labs_cat_sdk_2_0_2__rs__OwnerUtils.toLockingScript(pubKey) == ownerAddr);
+    require(_opcat_labs_cat_sdk_2_1_0__rs__OwnerUtils.toLockingScript(pubKey) == ownerAddr);
     return true;
   }
   static function checkPubKey(bytes pubKey) : bool {