Exemple #1
0
    def test_various_methods(self):
        self.assertEqual(Fixed8.FD(), Fixed8(100000000))
        self.assertEqual(Fixed8.FD(), Fixed8.One())

        sat = Fixed8.Satoshi()
        self.assertEqual(sat, Fixed8(1))
        self.assertEqual(sat.value, 1)

        negsat = Fixed8.NegativeSatoshi()
        self.assertEqual(negsat, Fixed8(-1))
        self.assertEqual(negsat.value, -1)

        zero = Fixed8.Zero()
        self.assertEqual(zero, Fixed8(0))
        self.assertEqual(zero.value, 0)

        decimal = 1.2
        f8 = Fixed8.FromDecimal(decimal)
        self.assertEqual(f8.value, f8.GetData())

        f8 = Fixed8.TryParse(123.123)
        f8 = Fixed8.TryParse(123)

        self.assertEqual(f8.Size(), 8)

        zero = Fixed8.TryParse(0)
        self.assertEqual(zero, Fixed8(0))

        self.assertEqual(Fixed8.TryParse("foo"), None)
        self.assertEqual(Fixed8.TryParse(-1, require_positive=True), None)
Exemple #2
0
    def Asset_Create(self, engine: ExecutionEngine):

        tx = engine.ScriptContainer

        asset_type = int(
            engine.CurrentContext.EvaluationStack.Pop().GetBigInteger())

        if asset_type not in AssetType.AllTypes() or \
                asset_type == AssetType.CreditFlag or \
                asset_type == AssetType.DutyFlag or \
                asset_type == AssetType.GoverningToken or \
                asset_type == AssetType.UtilityToken:
            return False

        if len(engine.CurrentContext.EvaluationStack.Peek().GetByteArray()
               ) > 1024:
            return False

        name = engine.CurrentContext.EvaluationStack.Pop().GetByteArray(
        ).decode('utf-8')

        amount = Fixed8(
            engine.CurrentContext.EvaluationStack.Pop().GetBigInteger())

        if amount == Fixed8.Zero() or amount < Fixed8.NegativeSatoshi():
            return False

        if asset_type == AssetType.Invoice and amount != Fixed8.NegativeSatoshi(
        ):
            return False

        precision = int(
            engine.CurrentContext.EvaluationStack.Pop().GetBigInteger())

        if precision > 8:
            return False

        if asset_type == AssetType.Share and precision != 0:
            return False

        if amount != Fixed8.NegativeSatoshi() and amount.value % pow(
                10, 8 - precision) != 0:
            return False

        ownerData = engine.CurrentContext.EvaluationStack.Pop().GetByteArray()

        try:
            owner = ECDSA.decode_secp256r1(ownerData, unhex=False).G
        except ValueError:
            return False

        if owner.IsInfinity:
            return False

        if not self.CheckWitnessPubkey(engine, owner):
            logger.error("check witness false...")
            return False

        admin = UInt160(
            data=engine.CurrentContext.EvaluationStack.Pop().GetByteArray())

        issuer = UInt160(
            data=engine.CurrentContext.EvaluationStack.Pop().GetByteArray())

        new_asset = AssetState(asset_id=tx.Hash,
                               asset_type=asset_type,
                               name=name,
                               amount=amount,
                               available=Fixed8.Zero(),
                               precision=precision,
                               fee_mode=0,
                               fee=Fixed8.Zero(),
                               fee_addr=UInt160(),
                               owner=owner,
                               admin=admin,
                               issuer=issuer,
                               expiration=Blockchain.Default().Height + 1 +
                               2000000,
                               is_frozen=False)

        asset = self._assets.ReplaceOrAdd(tx.Hash.ToBytes(), new_asset)

        # print("*****************************************************")
        # print("CREATED ASSET %s " % tx.Hash.ToBytes())
        # print("*****************************************************")
        engine.CurrentContext.EvaluationStack.PushT(
            StackItem.FromInterface(asset))

        return True