tx · EdjjTgyzwHjCFsQ7UERKWeNsBq3KsRPKJfyR9PzytBA6

3N8icXyy8nP599uu4C5Tydn7qwU8y9V2dP5:  -0.02100000 Waves

2023.03.13 02:04 [2487445] smart account 3N8icXyy8nP599uu4C5Tydn7qwU8y9V2dP5 > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "EdjjTgyzwHjCFsQ7UERKWeNsBq3KsRPKJfyR9PzytBA6",
    "fee": 2100000,
    "feeAssetId": null,
    "timestamp": 1678662236024,
    "version": 2,
    "chainId": 84,
    "sender": "3N8icXyy8nP599uu4C5Tydn7qwU8y9V2dP5",
    "senderPublicKey": "7g2oH3HDdgHMD6FU9M7WneDyHy7VzFBYp8VswdpHQa85",
    "proofs": [
        "UPYwJum9vpk8x6EoBuhPDiZcdbjA62CkDA53dF2sQSogpN4eyFvBJn6aTGBnPf11Jpi5ZuN1yPaUMZs2oDzG1mb"
    ],
    "script": "base64:BgJHCAISBAoCCAgSBAoCCAgSBgoECAgIBBIFCgMICAESBQoDBAgIEgYKBAQICAESBAoCCAgSAwoBCBIDCgEIEgQKAgEIEgMKAQgsAAxhZG1pbkFkZHJlc3MCIzNOOFVhcXJDVGp5cEdQV1hTdkZKVlNMdjIzYmZ1aVBvSkFoAAVBZG1pbgkBB0FkZHJlc3MBCQDZBAEFDGFkbWluQWRkcmVzcwAFd2F2ZXMCBVdBVkVTAAZhV2F2ZXMCDGFjY2VwdF93YXZlcwAFV0FWRVMFBHVuaXQABm5mZXRBYwIMYWN0aXZhdGVfbmZ0AARtYWluAgptYWluX2Fzc2V0AAFsAglscF9hc3NldF8AA2FhMQIGcG9vbF9fAAJzYQIPU1RBS0lOR19BTU9VTlRfAAJsYQINTEVBU0VfQU1PVU5UXwACaXgCA0lEXwAHcmF0ZUZlZQIYcGVyY2VudGFnZV9yYXRlX2ZlZV9zd2FwAAxyYXRlRmVlTGltaXQCDnJhdGVfZmVlX2xpbWl0AA1yYXRlRmVlSGVpZ2h0Ag9yYXRlX2ZlZV9oZWlnaHQADmRlcG9zaXRfaGVpZ2h0AhJEZXBvc2l0X0hlaWdodF9PZl8AAmFjAghhY3RpdmF0ZQAGcG9vbEFjAg5hY3RpdmF0ZV9wb29scwAGc3dhcEFjAg1hY3RpdmF0ZV9zd2FwAAtsaXF1aWRpdHlBYwISYWN0aXZhdGVfbGlxdWlkaXR5AANiY0QCE2Jsb2NrX2Rpc3RyaWJ1aXRpb24AAkQ4CQBsBgAKAAAACAAAAAAFBkhBTEZVUAAMdG90YWxfbG9ja2VkAhRUb3RhbF9Ub2tlbnNfTG9ja2VkXwAIaW5pRXJyb3ICMlNtYXJ0IGNvbnRyYWN0IGFkbWluIGhhcyBub3QgeWV0IGJlZW4gaW5pdGlhbGl6ZWQuAQFEAQFpCAkBBXZhbHVlAQkA7AcBBQFpCGRlY2ltYWxzAQJkTQIBaQFvCQBsBgAKAAAJAGUCBQFpBQFvAAAAAAUGSEFMRlVQAQNEMTABAWkJAGwGAAoAAAgJAQV2YWx1ZQEJAOwHAQUBaQhkZWNpbWFscwAAAAAFBkhBTEZVUAENdmFsaWRhdGVBc3NldAMGYXNzZXRTC3N0cmluZ0Fzc2V0B2FjV2F2ZXMDAwkAAAIFBmFzc2V0UwUFV0FWRVMJAAACBQtzdHJpbmdBc3NldAUFd2F2ZXMHAwUHYWNXYXZlcwYJAAIBAjRUaGUgc21hcnQgY29udHJhY3QgZG9lcyBub3QgY3VycmVudGx5IHN1cHBvcnQgV2F2ZXMuAwkAAAIFBmFzc2V0UwkA2QQBBQtzdHJpbmdBc3NldAYHAQhnZXRBc3NldAEBYQQHJG1hdGNoMAUBYQMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAFhBQckbWF0Y2gwCQDYBAEFAWEJAAIBAiFSZXF1aXJlcyBORlQgYXMgcGF5bWVudCBmb3Igc2FsZS4BAmtwAgZhc3NldDEGYXNzZXQyCQCsAgIJAKwCAgkArAICBQNhYTEFBmFzc2V0MQIBXwUGYXNzZXQyAQp2YWxpZFBvb2xLAQNrZXkEByRtYXRjaDAJAJoIAgUEdGhpcwUDa2V5AwkAAQIFByRtYXRjaDACA0ludAQBaQUHJG1hdGNoMAUBaQcBCWtwQWRkcmVzcwIHYWRkcmVzcwNrZXkEByRtYXRjaDAJAJoIAgUEdGhpcwkArAICCQCsAgIFA2tleQIBXwUHYWRkcmVzcwMJAAECBQckbWF0Y2gwAgNJbnQEAXQFByRtYXRjaDAFAXQAAAEGcG9vbEFBAwdhZGRyZXNzA2tleQVhc3NldAQHJG1hdGNoMAkAmggCBQR0aGlzCQCsAgIJAKwCAgkArAICCQCsAgIFB2FkZHJlc3MCAV8FA2tleQIBXwUFYXNzZXQDCQABAgUHJG1hdGNoMAIDSW50BAFhBQckbWF0Y2gwBQFhAAABBmFzc2V0UAIDa2V5BWFzc2V0BAckbWF0Y2gwCQCaCAIFBHRoaXMJAKwCAgkArAICBQNrZXkCAV8FBWFzc2V0AwkAAQIFByRtYXRjaDACA0ludAQBYQUHJG1hdGNoMAUBYQABARV2ZXJpZmlDb2xsZWN0aW9uRXhpc3QBAWEEByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHRoaXMFAWEDCQABAgUHJG1hdGNoMAIGU3RyaW5nBAFvBQckbWF0Y2gwBgcBDGdldEFzc2V0TmFtZQEHYXNzZXRJZAQHJG1hdGNoMAkA7AcBBQdhc3NldElkAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0BG5hbWUJAAIBAhBDYW4ndCBmaW5kIGFzc2V0ARRnZXRBc3NldElzc3VlQWRkcmVzcwEBYQQHJG1hdGNoMAkA7AcBBQFhAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0Bmlzc3VlcgkAAgECEENhbid0IGZpbmQgYXNzZXQBDnRvdGFsQXNzZXRQb29sAgNrZXkHYXNzZXRMcAQHJG1hdGNoMAkAmggCBQR0aGlzBQNrZXkDCQABAgUHJG1hdGNoMAIDSW50BAFhBQckbWF0Y2gwBQFhAwUHYXNzZXRMcAUCRDgAAQEFdmFsaWQDCGFzc2V0UGF5BXBhaXIxBXBhaXIyBAhwYWlyMV81OAMJAAACBQVwYWlyMQUFd2F2ZXMFBVdBVkVTCQDZBAEFBXBhaXIxBAhwYWlyMl81OAMJAAACBQVwYWlyMgUFd2F2ZXMFBVdBVkVTCQDZBAEFBXBhaXIyAwkAAAIFCGFzc2V0UGF5BQhwYWlyMV81OAUIcGFpcjJfNTgFCHBhaXIxXzU4AQRwa2V5AwZBc3NldDEGQXNzZXQyB2FkZHJlc3MJAKwCAgkArAICCQCsAgIFDmRlcG9zaXRfaGVpZ2h0CQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUHYWRkcmVzcwETZ2V0QW1vdW50QmxvY2tBc3NldAEHYXNzZXRJZAQHJG1hdGNoMAkAmggCBQR0aGlzBQdhc3NldElkAwkAAQIFByRtYXRjaDACA0ludAQBaQUHJG1hdGNoMAUBaQAAAQlNYWluQXNzZXQACQDZBAEJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBUFkbWluBQRtYWluAQ5HZXRSYXRlRmVlU3dhcAAJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBUFkbWluBQdyYXRlRmVlAQlscEJsb2NrZWQCB2FkZHJlc3MDa2V5BAckbWF0Y2gwCQCaCAIFBHRoaXMJAKwCAgkArAICCQCsAgICCVNUQUtFX0xQXwUHYWRkcmVzcwIBXwUDa2V5AwkAAQIFByRtYXRjaDACA0ludAQBYQUHJG1hdGNoMAUBYQAACwFpAQRTd2FwAgZBc3NldDEGQXNzZXQyBApjdXJyZW50S2V5CQDYBAEICAUBaQZjYWxsZXIFYnl0ZXMEB2FjV2F2ZXMJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQZhV2F2ZXMEBXBvd2VyCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUCYWMEDHN3YXBBY3RpdmF0ZQkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FBnN3YXBBYwQHcG9vbEtleQkBAmtwAgUGQXNzZXQxBQZBc3NldDIEA2tleQkBCnZhbGlkUG9vbEsBBQdwb29sS2V5BAZhc3NldDEICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAQGYXNzZXQyCAkAkQMCCAUBaQhwYXltZW50cwABB2Fzc2V0SWQECWxwQXNzZXRJZAkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwkArAICBQFsCQECa3ACBQZBc3NldDEFBkFzc2V0MgQLdG90YWxBc3NldDEJAQ50b3RhbEFzc2V0UG9vbAIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUGQXNzZXQxBwQLdG90YWxBc3NldDIJAQ50b3RhbEFzc2V0UG9vbAIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUGQXNzZXQyBwQRZmVlUmF0ZVBlcmNlbnR1YWwJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBUFkbWluBQdyYXRlRmVlBAhwckFzc2V0MQkAuQICCQC2AgEICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQC8AgMJALYCAQUCRDgJALYCAQULdG90YWxBc3NldDIJALYCAQULdG90YWxBc3NldDEEC3ByaWNlQXNzZXQxCQCgAwEJALoCAgkAuAICBQhwckFzc2V0MQkAuQICCQC6AgIFCHByQXNzZXQxCQC2AgEFEWZlZVJhdGVQZXJjZW50dWFsCQC2AgEAZAkAtgIBBQJEOAQIcHJBc3NldDIJALkCAgkAtgIBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAvAIDCQC2AgEFAkQ4CQC2AgEFC3RvdGFsQXNzZXQxCQC2AgEFC3RvdGFsQXNzZXQyBAtwcmljZUFzc2V0MgkAoAMBCQC6AgIJALgCAgUIcHJBc3NldDIJALkCAgkAugICBQhwckFzc2V0MgkAtgIBBRFmZWVSYXRlUGVyY2VudHVhbAkAtgIBAGQJALYCAQUCRDgECXNlbmRWYWx1ZQMDCQAAAgUGYXNzZXQxBQVXQVZFUwkAAAIFBkFzc2V0MQUFd2F2ZXMHBQtwcmljZUFzc2V0MQMJAAACBQZhc3NldDEJANkEAQUGQXNzZXQxBQtwcmljZUFzc2V0MQULcHJpY2VBc3NldDIEDmFzc2V0VXBkYXRlUGF5AwkAAAIFBmFzc2V0MQUFV0FWRVMFBXdhdmVzAwkAAAIFBmFzc2V0MQkA2QQBBQZBc3NldDEFBkFzc2V0MQUGQXNzZXQyBA9hc3NldFVwZGF0ZVN3YXADCQAAAgUGYXNzZXQxBQVXQVZFUwUFd2F2ZXMDCQAAAgUGYXNzZXQxCQDZBAEFBkFzc2V0MQUGQXNzZXQyBQZBc3NldDEEDWFzc2V0U2VuZFN3YXAJAQV2YWxpZAMICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAUGQXNzZXQxBQZBc3NldDIEA24xcwkAZQIJAQZhc3NldFACCQECa3ACBQZBc3NldDEFBkFzc2V0MgUPYXNzZXRVcGRhdGVTd2FwBQlzZW5kVmFsdWUEAm53CQBlAgkBE2dldEFtb3VudEJsb2NrQXNzZXQBBQ9hc3NldFVwZGF0ZVN3YXAFCXNlbmRWYWx1ZQQHbmV3VXBkYQMJAGYCAAAFA24xcwAABQNuMXMEDW5ld1VwZGF0ZVN3YXADCQBmAgAABQJudwAABQJudwQCRHgEByRtYXRjaDAICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAMJAAECBQckbWF0Y2gwAgRVbml0BAFvBQckbWF0Y2gwCQBsBgAKAAAACAAAAAAFBkhBTEZVUAMJAAECBQckbWF0Y2gwAgpCeXRlVmVjdG9yBAF4BQckbWF0Y2gwCQBsBgAKAAAICQEFdmFsdWUBCQDsBwEFAXgIZGVjaW1hbHMAAAAABQZIQUxGVVAJAAIBAgtNYXRjaCBlcnJvcgMFBXBvd2VyAwkBASEBBQxzd2FwQWN0aXZhdGUDAwkBASEBCQAAAgUGQXNzZXQxBQZBc3NldDIDCQENdmFsaWRhdGVBc3NldAMFBmFzc2V0MQUGQXNzZXQxBQdhY1dhdmVzBgkBDXZhbGlkYXRlQXNzZXQDBQZhc3NldDEFBkFzc2V0MgUHYWNXYXZlcwcDCQECIT0CBQNrZXkHAwkAAAIICQCRAwIIBQFpCHBheW1lbnRzAAEHYXNzZXRJZAkBCU1haW5Bc3NldAADCQAAAggJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQJAQ5HZXRSYXRlRmVlU3dhcAADAwkAZgIFC3RvdGFsQXNzZXQxAAIGCQBmAgULdG90YWxBc3NldDIAAgQTb2xkUmF0ZUZlZVN3YXBUb3RhbAQHJG1hdGNoMAkAmggCBQR0aGlzCQCsAgIFB3Bvb2xLZXkCDl9yYXRlX2ZlZV9zd2FwAwkAAQIFByRtYXRjaDACA0ludAQBbwUHJG1hdGNoMAkAZAIFAW8JAQ5HZXRSYXRlRmVlU3dhcAAJAQ5HZXRSYXRlRmVlU3dhcAAJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwkBB0FkZHJlc3MBCAgFAWkGY2FsbGVyBWJ5dGVzAwkAZgIAAAUJc2VuZFZhbHVlBQJEeAUJc2VuZFZhbHVlBQ1hc3NldFNlbmRTd2FwCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQ9hc3NldFVwZGF0ZVN3YXAFDW5ld1VwZGF0ZVN3YXAJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUPYXNzZXRVcGRhdGVTd2FwBQduZXdVcGRhCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FDmFzc2V0VXBkYXRlUGF5CQBkAgkBBmFzc2V0UAIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBQ5hc3NldFVwZGF0ZVBheQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIFDmFzc2V0VXBkYXRlUGF5CQBkAgkBE2dldEFtb3VudEJsb2NrQXNzZXQBBQ5hc3NldFVwZGF0ZVBheQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIJANgEAQkBCU1haW5Bc3NldAAJAGQCCQETZ2V0QW1vdW50QmxvY2tBc3NldAEJANgEAQkBCU1haW5Bc3NldAAICQCRAwIIBQFpCHBheW1lbnRzAAEGYW1vdW50CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFB3Bvb2xLZXkCDl9yYXRlX2ZlZV9zd2FwBRNvbGRSYXRlRmVlU3dhcFRvdGFsBQNuaWwJAAIBAhZQb29sIGhhcyBubyBsaXF1aWRpdHkuCQACAQkArAICCQCsAgICDVN3YXAgZGVuaWVkISAJAKQDAQkBDkdldFJhdGVGZWVTd2FwAAIkIEJpY29uIGlzIHJlcXVpcmVkIGZvciB0aGUgc3dhcCBmZWUuCQACAQISSW52YWxpZCByYXRlIGFzc2V0CQACAQIRSW52YWxpZCBTd2FwIEtleS4JAAIBAiBBc3NldDEgY2Fubm90IGJlIGVxdWFsIHRvIEFzc2V0MgkAAgECJFN3YXAgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgkAAgECJGRBcHAgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgFpAQxBZGRMaXF1aWRpdHkCBkFzc2V0MQZBc3NldDIEBXBvd2VyCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUCYWMEDHBvb2xBY3RpdmF0ZQkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FBnBvb2xBYwQHYWNXYXZlcwkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FBmFXYXZlcwQDa2V5CQEKdmFsaWRQb29sSwEJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBAZhc3NldDEICQCRAwIIBQFpCHBheW1lbnRzAAAHYXNzZXRJZAQGYXNzZXQyCAkAkQMCCAUBaQhwYXltZW50cwABB2Fzc2V0SWQECWxwQXNzZXRJZAkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwkArAICBQFsCQECa3ACBQZBc3NldDEFBkFzc2V0MgQPdG90YWxBc3NldDFQb29sAwkAZgIAAgkBDnRvdGFsQXNzZXRQb29sAgkArAICCQCsAgIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDEHCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkBDnRvdGFsQXNzZXRQb29sAgkArAICCQCsAgIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDEHBA90b3RhbEFzc2V0MlBvb2wDCQBmAgACCQEOdG90YWxBc3NldFBvb2wCCQCsAgIJAKwCAgkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FBkFzc2V0MQcICQCRAwIIBQFpCHBheW1lbnRzAAEGYW1vdW50CQEOdG90YWxBc3NldFBvb2wCCQCsAgIJAKwCAgkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FBkFzc2V0MgcEB3RvdGFsTHAJAQ50b3RhbEFzc2V0UG9vbAIFCWxwQXNzZXRJZAYEDHByaWNlTHBBc3NldAkAaQIJAGQCBQ90b3RhbEFzc2V0MVBvb2wFD3RvdGFsQXNzZXQyUG9vbAUHdG90YWxMcAQOcXVhbnRpdHlBc3NldDIJAGgCCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAaQIFD3RvdGFsQXNzZXQyUG9vbAUPdG90YWxBc3NldDFQb29sBAdyYXRlVG9wCQBkAggJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQJAGkCCQBoAggJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQAAgBkBApyYXRlQm90dG9tCQBlAggJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQJAGkCCQBoAggJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQAAgBkBAhWYWxpZGF0ZQMDAwkAAAIICQCRAwIIBQFpCHBheW1lbnRzAAEGYW1vdW50BQ5xdWFudGl0eUFzc2V0MgYJAGYCBQdyYXRlVG9wCAkAkQMCCAUBaQhwYXltZW50cwABBmFtb3VudAYJAGYCCAkAkQMCCAUBaQhwYXltZW50cwABBmFtb3VudAUKcmF0ZUJvdHRvbQYHAwUFcG93ZXIDCQEBIQEFDHBvb2xBY3RpdmF0ZQMDAwkBASEBCQAAAgUGYXNzZXQxBQZhc3NldDIJAQ12YWxpZGF0ZUFzc2V0AwUGYXNzZXQxBQZBc3NldDEFB2FjV2F2ZXMHCQENdmFsaWRhdGVBc3NldAMFBmFzc2V0MgUGQXNzZXQyBQdhY1dhdmVzBwMJAQIhPQIFA2tleQcDBQhWYWxpZGF0ZQQKY3VycmVudEtleQkA2AQBCAgFAWkGY2FsbGVyBWJ5dGVzBA1jdXJyZW50QW1vdW50CQEJa3BBZGRyZXNzAgUKY3VycmVudEtleQkBAmtwAgUGQXNzZXQxBQZBc3NldDIEE2N1cnJlbnRBbW91bnRBc3NldDEJAQZwb29sQUEDBQpjdXJyZW50S2V5CQECa3ACBQZBc3NldDEFBkFzc2V0MgUGQXNzZXQxBBNjdXJyZW50QW1vdW50QXNzZXQyCQEGcG9vbEFBAwUKY3VycmVudEtleQkBAmtwAgUGQXNzZXQxBQZBc3NldDIFBkFzc2V0MgQKYXNzZXQxcG9vbAkBBmFzc2V0UAIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBQZBc3NldDEECmFzc2V0MnBvb2wJAQZhc3NldFACCQECa3ACBQZBc3NldDEFBkFzc2V0MgUGQXNzZXQyBAlyZWNlaXZlTHADCQAAAgUPdG90YWxBc3NldDFQb29sCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAaAIAAQUCRDgJAKADAQkAugICCQC3AgIJALkCAgkAtgIBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAtgIBBQJEOAkAuQICCQC2AgEICQCRAwIIBQFpCHBheW1lbnRzAAEGYW1vdW50CQC2AgEFAkQ4CQC6AgIJALcCAgkAuQICCQC2AgEFD3RvdGFsQXNzZXQxUG9vbAkAtgIBBQJEOAkAuQICCQC2AgEFD3RvdGFsQXNzZXQyUG9vbAkAtgIBBQJEOAkAtgIBBQd0b3RhbExwBBZuZXdjdXJyZW50QW1vdW50QXNzZXQxCQBkAgUTY3VycmVudEFtb3VudEFzc2V0MQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQEFm5ld2N1cnJlbnRBbW91bnRBc3NldDIJAGQCBRNjdXJyZW50QW1vdW50QXNzZXQyCAkAkQMCCAUBaQhwYXltZW50cwABBmFtb3VudAQQbmV3Y3VycmVudEFtb3VudAkAZAIFDWN1cnJlbnRBbW91bnQFCXJlY2VpdmVMcAQNbmV3YXNzZXQxcG9vbAkAZAIFCmFzc2V0MXBvb2wICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50BA1uZXdhc3NldDJwb29sCQBkAgUKYXNzZXQycG9vbAgJAJEDAggFAWkIcGF5bWVudHMAAQZhbW91bnQJAMwIAgkBB1JlaXNzdWUDCQDZBAEFCWxwQXNzZXRJZAUJcmVjZWl2ZUxwBgkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCQEHQWRkcmVzcwEICAUBaQZjYWxsZXIFYnl0ZXMFCXJlY2VpdmVMcAkA2QQBBQlscEFzc2V0SWQJAMwIAgkBDEludGVnZXJFbnRyeQIJAQRwa2V5AwUGQXNzZXQxBQZBc3NldDIFCmN1cnJlbnRLZXkFBmhlaWdodAkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgIJAKwCAgkArAICBQpjdXJyZW50S2V5AgFfCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUGQXNzZXQxBRZuZXdjdXJyZW50QW1vdW50QXNzZXQxCQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkArAICCQCsAgIFCmN1cnJlbnRLZXkCAV8JAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDIFFm5ld2N1cnJlbnRBbW91bnRBc3NldDIJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUKY3VycmVudEtleQUQbmV3Y3VycmVudEFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDEFDW5ld2Fzc2V0MXBvb2wJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUGQXNzZXQyBQ1uZXdhc3NldDJwb29sCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQZBc3NldDEJAGQCCQETZ2V0QW1vdW50QmxvY2tBc3NldAEFBkFzc2V0MQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAMwIAgkBDEludGVnZXJFbnRyeQIFBkFzc2V0MgkAZAIJARNnZXRBbW91bnRCbG9ja0Fzc2V0AQUGQXNzZXQyCAkAkQMCCAUBaQhwYXltZW50cwABBmFtb3VudAkAzAgCCQEMSW50ZWdlckVudHJ5AgUJbHBBc3NldElkCQBkAgkBE2dldEFtb3VudEJsb2NrQXNzZXQBBQlscEFzc2V0SWQFCXJlY2VpdmVMcAUDbmlsCQACAQkArAICCQCsAgIJAKwCAgkArAICCQCsAgICP1BheW1lbnQgb2YgaW52YWxpZCAxLzEgYW1vdW50cyB0byB0aGUgUG9vbC4gVHJ5IEFzc2V0Mjoge3ZhbHVlOgkApAMBCQBoAggJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJAGkCBQ90b3RhbEFzc2V0MlBvb2wFD3RvdGFsQXNzZXQxUG9vbAIMfSBSZWNlaXZlZDogCQCkAwEICQCRAwIIBQFpCHBheW1lbnRzAAEGYW1vdW50AgsgVmFsaWRhdGU6IAkApQMBBQhWYWxpZGF0ZQkAAgECEUludmFsaWQgUG9vbCBLZXkuCQACAQIgQXNzZXQxIGNhbm5vdCBiZSBlcXVhbCB0byBBc3NldDIJAAIBAilsaXF1aWRpdHkgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgkAAgECJGRBcHAgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgFpAQxBY3RpdmF0ZVBvb2wEBmFzc2V0MQZhc3NldDIETmFtZQpjdXN0b21OYW1lBApuYW1lQXNzZXQxAwkAAAIFBmFzc2V0MQUFd2F2ZXMFBXdhdmVzCQEMZ2V0QXNzZXROYW1lAQkA2QQBBQZhc3NldDEECm5hbWVBc3NldDIDCQAAAgUGYXNzZXQyBQV3YXZlcwUFd2F2ZXMJAQxnZXRBc3NldE5hbWUBCQDZBAEFBmFzc2V0MgQEbmFtZQMFCmN1c3RvbU5hbWUFBE5hbWUJAKwCAgkArAICBQpuYW1lQXNzZXQxAgFfBQpuYW1lQXNzZXQyBANrZXkJAQp2YWxpZFBvb2xLAQkBAmtwAgUGYXNzZXQxBQZhc3NldDIDCQAAAggFAWkGY2FsbGVyCQEUZ2V0QXNzZXRJc3N1ZUFkZHJlc3MBCQDZBAEFBmFzc2V0MQMJAQIhPQIFA2tleQcEDWFzc2V0THBDcmVhdGUJAMIIBQUEbmFtZQkArAICCQCsAgIJAKwCAgIuTFAgYXNzZXQgZm9yIHBvb2wgbGlxdWlkaXR5IGluIEJpY29uIERFWCBwYWlyIAUGYXNzZXQxAgFfBQZhc3NldDIJAGgCAAEFAkQ4AAgGBAlpZEFzc2V0THAJALgIAQUNYXNzZXRMcENyZWF0ZQkAzAgCCQELU3RyaW5nRW50cnkCCQCsAgIFAWwJAQJrcAIFBmFzc2V0MQUGYXNzZXQyCQDYBAEFCWlkQXNzZXRMcAkAzAgCBQ1hc3NldExwQ3JlYXRlBQNuaWwJAAIBAipJbnZhbGlkIFBvb2wgS2V5LiBUcnkgaW52ZXJ0aW5nIHRoZSBhc3NldHMJAAIBAkJPbmx5IHRoZSBpc3N1ZXIgYWRkcmVzcyBvZiBhc3NldDEgaXRzZWxmIGNhbiBpbnZva2UgdGhpcyBmdW5jdGlvbi4BaQEPUmVtb3ZlTGlxdWlkaXR5AwZBc3NldDEGQXNzZXQyBkFtb3VudAQKY3VycmVudEtleQkA2AQBCAgFAWkGY2FsbGVyBWJ5dGVzBAVwb3dlcgkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FAmFjBAxwb29sQWN0aXZhdGUJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQZwb29sQWMEB2FjV2F2ZXMJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQZhV2F2ZXMEB3Bvb2xLZXkJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBANrZXkJAQp2YWxpZFBvb2xLAQUHcG9vbEtleQQGYXNzZXQxAwkAAAIFBkFzc2V0MQUFd2F2ZXMDBQdhY1dhdmVzBQVXQVZFUwkAAgECNFRoZSBzbWFydCBjb250cmFjdCBkb2VzIG5vdCBjdXJyZW50bHkgc3VwcG9ydCBXYXZlcy4JANkEAQUGQXNzZXQxBAZhc3NldDIDCQAAAgUGQXNzZXQyBQV3YXZlcwMFB2FjV2F2ZXMFBVdBVkVTCQACAQI0VGhlIHNtYXJ0IGNvbnRyYWN0IGRvZXMgbm90IGN1cnJlbnRseSBzdXBwb3J0IFdhdmVzLgkA2QQBBQZBc3NldDIECWxwQXNzZXRJZAkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwkArAICBQFsCQECa3ACBQZBc3NldDEFBkFzc2V0MgQNY3VycmVudEFtb3VudAkBCWtwQWRkcmVzcwIFCmN1cnJlbnRLZXkJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBA9hbW91bnRMcEJsb2NrZWQJAQlscEJsb2NrZWQCBQpjdXJyZW50S2V5BQdwb29sS2V5BAd0b3RhbExQCQEOdG90YWxBc3NldFBvb2wCBQlscEFzc2V0SWQGBA90b3RhbEFzc2V0MVBvb2wJAQ50b3RhbEFzc2V0UG9vbAIJAKwCAgkArAICCQECa3ACBQZBc3NldDEFBkFzc2V0MgIBXwUGQXNzZXQxBwQPdG90YWxBc3NldDJQb29sCQEOdG90YWxBc3NldFBvb2wCCQCsAgIJAKwCAgkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FBkFzc2V0MgcDBQVwb3dlcgMJAQEhAQUMcG9vbEFjdGl2YXRlAwkBASEBCQAAAgUGQXNzZXQxBQZBc3NldDIDCQECIT0CBQNrZXkHAwkBASEBCQAAAgUNY3VycmVudEFtb3VudAAAAwkAZwIJAGUCBQ1jdXJyZW50QW1vdW50BQ9hbW91bnRMcEJsb2NrZWQFBkFtb3VudAMDCQBmAgUPdG90YWxBc3NldDFQb29sAAIGCQBmAgUPdG90YWxBc3NldDJQb29sAAIEDXJlY2VpdmVBc3NldDEJAGUCCQCgAwEJALoCAgkAuQICCQC8AgMJALYCAQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQJALYCAQUCRDgJALYCAQUHdG90YWxMUAkAtgIBBQ90b3RhbEFzc2V0MVBvb2wJALYCAQUCRDgAAQQNcmVjZWl2ZUFzc2V0MgkAZQIJAKADAQkAugICCQC5AgIJALwCAwkAtgIBCAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAkAtgIBBQJEOAkAtgIBBQd0b3RhbExQCQC2AgEFD3RvdGFsQXNzZXQyUG9vbAkAtgIBBQJEOAABBAphc3NldDFwb29sCQEGYXNzZXRQAgkBAmtwAgUGQXNzZXQxBQZBc3NldDIFBkFzc2V0MQQKYXNzZXQycG9vbAkBBmFzc2V0UAIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBQZBc3NldDIEE2N1cnJlbnRBbW91bnRBc3NldDEJAQZwb29sQUEDBQpjdXJyZW50S2V5CQECa3ACBQZBc3NldDEFBkFzc2V0MgUGQXNzZXQxBBNjdXJyZW50QW1vdW50QXNzZXQyCQEGcG9vbEFBAwUKY3VycmVudEtleQkBAmtwAgUGQXNzZXQxBQZBc3NldDIFBkFzc2V0MgQWbmV3Y3VycmVudEFtb3VudEFzc2V0MQkAZQIFE2N1cnJlbnRBbW91bnRBc3NldDEFDXJlY2VpdmVBc3NldDEEFm5ld2N1cnJlbnRBbW91bnRBc3NldDIJAGUCBRNjdXJyZW50QW1vdW50QXNzZXQyBQ1yZWNlaXZlQXNzZXQyBBBuZXdjdXJyZW50QW1vdW50CQBlAgUNY3VycmVudEFtb3VudAUGQW1vdW50BA1uZXdhc3NldDFwb29sCQBlAgUKYXNzZXQxcG9vbAUNcmVjZWl2ZUFzc2V0MQQNbmV3YXNzZXQycG9vbAkAZQIFCmFzc2V0MnBvb2wFDXJlY2VpdmVBc3NldDIDCQAAAggJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkCQDZBAEFCWxwQXNzZXRJZAMJAAACBQZBbW91bnQICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50CQDMCAIJAQRCdXJuAgkA2QQBBQlscEFzc2V0SWQFBkFtb3VudAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCQEHQWRkcmVzcwEICAUBaQZjYWxsZXIFYnl0ZXMFDXJlY2VpdmVBc3NldDEFBmFzc2V0MQkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCQEHQWRkcmVzcwEICAUBaQZjYWxsZXIFYnl0ZXMFDXJlY2VpdmVBc3NldDIFBmFzc2V0MgkAzAgCCQEMSW50ZWdlckVudHJ5AgkBBHBrZXkDBQZBc3NldDEFBkFzc2V0MgUKY3VycmVudEtleQUGaGVpZ2h0CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkArAICCQCsAgIFCmN1cnJlbnRLZXkCAV8JAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDEFFm5ld2N1cnJlbnRBbW91bnRBc3NldDEJAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkArAICCQCsAgIJAKwCAgUKY3VycmVudEtleQIBXwkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FBkFzc2V0MgUWbmV3Y3VycmVudEFtb3VudEFzc2V0MgkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQpjdXJyZW50S2V5BRBuZXdjdXJyZW50QW1vdW50CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkBAmtwAgUGQXNzZXQxBQZBc3NldDICAV8FBkFzc2V0MQUNbmV3YXNzZXQxcG9vbAkAzAgCCQEMSW50ZWdlckVudHJ5AgkArAICCQCsAgIJAQJrcAIFBkFzc2V0MQUGQXNzZXQyAgFfBQZBc3NldDIFDW5ld2Fzc2V0MnBvb2wJAMwIAgkBDEludGVnZXJFbnRyeQIFBkFzc2V0MQkAZQIJARNnZXRBbW91bnRCbG9ja0Fzc2V0AQUGQXNzZXQxBQ1yZWNlaXZlQXNzZXQxCQDMCAIJAQxJbnRlZ2VyRW50cnkCBQZBc3NldDIJAGUCCQETZ2V0QW1vdW50QmxvY2tBc3NldAEFBkFzc2V0MgUNcmVjZWl2ZUFzc2V0MgkAzAgCCQEMSW50ZWdlckVudHJ5AgUJbHBBc3NldElkCQBlAgkBE2dldEFtb3VudEJsb2NrQXNzZXQBBQlscEFzc2V0SWQFBkFtb3VudAUDbmlsCQACAQkArAICAkhXaXRoZHJhd2FsIGFtb3VudCBsb3dlciB0aGFuIGFzc2V0IGxwIGFtb3VudC4gWW91ciBMcCBhbW91bnQgYXZhaWxhYmxlOiAJAKQDAQUGQW1vdW50CQACAQI5UmVxdWlyZXMgYW4gbHAgYXNzZXQgYXMgcGF5bWVudCB0byByZW1vdmUgbG9ja2VkIGFtb3VudHMuCQACAQIWUG9vbCBoYXMgbm8gbGlxdWlkaXR5LgkAAgEJAKwCAgJUQW1vdW50IHRvIGJlIHdpdGhkcmF3biBncmVhdGVyIHRoYW4gdGhlIGFtb3VudCBhdmFpbGFibGUgZm9yIHdpdGhkcmF3YWwuIEF2YWlsYWJsZTogCQCkAwEFBkFtb3VudAkAAgECK1lvdSBoYXZlIG5vIGxvY2tlZCB2YWx1ZXMg4oCL4oCLaW4gdGhlIHBvb2wJAAIBAhFJbnZhbGlkIFBvb2wgS2V5LgkAAgECIEFzc2V0MSBjYW5ub3QgYmUgZXF1YWwgdG8gQXNzZXQyCQACAQIpbGlxdWlkaXR5IGlzIGN1cnJlbnRseSB1bmRlciBtYWludGVuYW5jZS4JAAIBAiRkQXBwIGlzIGN1cnJlbnRseSB1bmRlciBtYWludGVuYW5jZS4BaQEFU3Rha2UDBHBvb2wGQXNzZXQxBkFzc2V0MgQFcG93ZXIJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQJhYwQObGlxdWlkaXR5UG93ZXIJARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQtsaXF1aWRpdHlBYwQJbHBBc3NldElkAwUEcG9vbAkBEUBleHRyTmF0aXZlKDEwNTMpAgUFQWRtaW4JAKwCAgUBbAkBAmtwAgUGQXNzZXQxBQZBc3NldDIJAQlNYWluQXNzZXQABAVscEFJZAQHJG1hdGNoMAUJbHBBc3NldElkAwkAAQIFByRtYXRjaDACBlN0cmluZwQCeGkFByRtYXRjaDAJANkEAQUCeGkDCQABAgUHJG1hdGNoMAIKQnl0ZVZlY3RvcgQBeAUHJG1hdGNoMAUBeAkAAgECC01hdGNoIGVycm9yAwUFcG93ZXIDCQEBIQEFDmxpcXVpZGl0eVBvd2VyAwkBAiE9AggJAJEDAggFAWkIcGF5bWVudHMAAAdhc3NldElkBQVscEFJZAkAAgEJAKwCAgkArAICAiNJbnZhbGlkIGFzc2V0ISBLaW5kbHkgRGVwb3NpdCBPbmx5IAkA2AQBCQEJTWFpbkFzc2V0AAISIG9yIHZhbGlkIGFzc2V0IGxwAwkBASEBBQRwb29sBApjdXJyZW50S2V5CQDYBAEICAUBaQZjYWxsZXIFYnl0ZXMEDWN1cnJlbnRBbW91bnQEByRtYXRjaDAJAJoIAgUEdGhpcwUKY3VycmVudEtleQMJAAECBQckbWF0Y2gwAgNJbnQEAWEFByRtYXRjaDAFAWEAAAQBaAMJAAACBQ1jdXJyZW50QW1vdW50AAAFBmhlaWdodAkBC3ZhbHVlT3JFbHNlAgkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwkArAICBQ5kZXBvc2l0X2hlaWdodAUKY3VycmVudEtleQUGaGVpZ2h0BAluZXdBbW91bnQJAGQCBQ1jdXJyZW50QW1vdW50CAkAkQMCCAUBaQhwYXltZW50cwAABmFtb3VudAQKdXNlcmFtb3VudAkBDEludGVnZXJFbnRyeQIFCmN1cnJlbnRLZXkFCW5ld0Ftb3VudAQRdXNlcmRlcG9zaXRoZWlnaHQJAQxJbnRlZ2VyRW50cnkCCQCsAgIFDmRlcG9zaXRfaGVpZ2h0BQpjdXJyZW50S2V5BQFoBBNwcmV2aW91c2xvY2tiYWxhbmNlBAckbWF0Y2gwCQCaCAIFBHRoaXMCFFRvdGFsX1Rva2Vuc19Mb2NrZWQ6AwkAAQIFByRtYXRjaDACA0ludAQBYQUHJG1hdGNoMAUBYQAABAp0b3RhbHRva2VuCQBkAgUTcHJldmlvdXNsb2NrYmFsYW5jZQgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQEA1RMVgkBDEludGVnZXJFbnRyeQICFFRvdGFsX1Rva2Vuc19Mb2NrZWQ6BQp0b3RhbHRva2VuCQDMCAIFCnVzZXJhbW91bnQJAMwIAgURdXNlcmRlcG9zaXRoZWlnaHQJAMwIAgUDVExWBQNuaWwEB3Bvb2xLZXkJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBANrZXkJAQp2YWxpZFBvb2xLAQUHcG9vbEtleQMJAQIhPQIFA2tleQcECmN1cnJlbnRLZXkJANgEAQgIBQFpBmNhbGxlcgVieXRlcwQNY3VycmVudEFtb3VudAQHJG1hdGNoMAkAmggCBQR0aGlzCQCsAgIJAKwCAgkArAICAglTVEFLRV9MUF8FCmN1cnJlbnRLZXkCAV8FB3Bvb2xLZXkDCQABAgUHJG1hdGNoMAIDSW50BAFhBQckbWF0Y2gwBQFhAAAEAWgDCQAAAgUNY3VycmVudEFtb3VudAAABQZoZWlnaHQJAQt2YWx1ZU9yRWxzZQIJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMJAKwCAgkArAICCQCsAgIJAKwCAgUOZGVwb3NpdF9oZWlnaHQCAV8FCmN1cnJlbnRLZXkCAV8FB3Bvb2xLZXkFBmhlaWdodAQJbmV3QW1vdW50CQBkAgUNY3VycmVudEFtb3VudAgJAJEDAggFAWkIcGF5bWVudHMAAAZhbW91bnQECnVzZXJhbW91bnQJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkArAICAglTVEFLRV9MUF8FCmN1cnJlbnRLZXkCAV8FB3Bvb2xLZXkFCW5ld0Ftb3VudAQRdXNlcmRlcG9zaXRoZWlnaHQJAQxJbnRlZ2VyRW50cnkCCQCsAgIJAKwCAgkArAICCQCsAgIFDmRlcG9zaXRfaGVpZ2h0AgFfBQpjdXJyZW50S2V5AgFfBQdwb29sS2V5BQZoZWlnaHQEE3ByZXZpb3VzbG9ja2JhbGFuY2UEByRtYXRjaDAJAJoIAgUEdGhpcwkArAICAhdUb3RhbF9Ub2tlbnNfTFBfTG9ja2VkXwUHcG9vbEtleQMJAAECBQckbWF0Y2gwAgNJbnQEAWEFByRtYXRjaDAFAWEAAAQKdG90YWx0b2tlbgkAZAIFE3ByZXZpb3VzbG9ja2JhbGFuY2UICQCRAwIIBQFpCHBheW1lbnRzAAAGYW1vdW50BANUTFYJAQxJbnRlZ2VyRW50cnkCCQCsAgICF1RvdGFsX1Rva2Vuc19MUF9Mb2NrZWRfBQdwb29sS2V5BQp0b3RhbHRva2VuCQDMCAIFCnVzZXJhbW91bnQJAMwIAgURdXNlcmRlcG9zaXRoZWlnaHQJAMwIAgUDVExWBQNuaWwJAAIBAhFJbnZhbGlkIFBvb2wga2V5LgkAAgECKWxpcXVpZGl0eSBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuCQACAQIkZEFwcCBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuAWkBB1Vuc3Rha2UEBHBvb2wGQXNzZXQxBkFzc2V0MgZhbW91bnQEBXBvd2VyCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUCYWMEDmxpcXVpZGl0eVBvd2VyCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgULbGlxdWlkaXR5QWMEB3Bvb2xLZXkJAQJrcAIFBkFzc2V0MQUGQXNzZXQyBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAMFBXBvd2VyAwkBASEBBQ5saXF1aWRpdHlQb3dlcgQKY3VycmVudEtleQkA2AQBCAgFAWkGY2FsbGVyBWJ5dGVzBA1jdXJyZW50QW1vdW50BAckbWF0Y2gwAwUEcG9vbAkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwkArAICCQCsAgIJAKwCAgIJU1RBS0VfTFBfBQpjdXJyZW50S2V5AgFfCQECa3ACBQZBc3NldDEFBkFzc2V0MgkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwUKY3VycmVudEtleQMJAAECBQckbWF0Y2gwAgNJbnQEAWEFByRtYXRjaDAFAWEAAAQRc3dhcGhlaWdodGtleW5hbWUDBQRwb29sCQCsAgIJAKwCAgkArAICCQCsAgIFDmRlcG9zaXRfaGVpZ2h0AgFfBQpjdXJyZW50S2V5AgFfCQECa3ACBQZBc3NldDEFBkFzc2V0MgkArAICBQ5kZXBvc2l0X2hlaWdodAUKY3VycmVudEtleQQTcHJldmlvdXNsb2NrYmFsYW5jZQMFBHBvb2wJARFAZXh0ck5hdGl2ZSgxMDUwKQIFBHRoaXMJAKwCAgIXVG90YWxfVG9rZW5zX0xQX0xvY2tlZF8JAQJrcAIFBkFzc2V0MQUGQXNzZXQyCQERQGV4dHJOYXRpdmUoMTA1MCkCBQR0aGlzAhRUb3RhbF9Ub2tlbnNfTG9ja2VkOgQKdG90YWx0b2tlbgkAZQIFE3ByZXZpb3VzbG9ja2JhbGFuY2UFBmFtb3VudAQEZGlmZgkAZQIFBmhlaWdodAkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwURc3dhcGhlaWdodGtleW5hbWUEA2JjZAkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwUDYmNEBAZyZXdhcmQJAGgCCQBoAgUEZGlmZgUDYmNkBQJEOAQDb29kBAckbWF0Y2gwCQCfCAEJAKwCAgUHcG9vbEtleQIOX3JhdGVfZmVlX3N3YXADCQABAgUHJG1hdGNoMAIDSW50BAJpdwUHJG1hdGNoMAUCaXcAAAQEb2xkVAQHJG1hdGNoMAkAnwgBCQCsAgIFB3Bvb2xLZXkCDl9yYXRlX2ZlZV9zd2FwAwkAAQIFByRtYXRjaDACA0ludAQDaWRkBQckbWF0Y2gwCQBpAgUDaWRkCQBpAgUTcHJldmlvdXNsb2NrYmFsYW5jZQUGYW1vdW50AAAEB2ZlZUNhbGMDCQAAAgUGQXNzZXQxCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzBQRtYWluCQBpAgUGcmV3YXJkCQBpAgUTcHJldmlvdXNsb2NrYmFsYW5jZQUGYW1vdW50BQRvbGRUAwkAZgIAAAUGYW1vdW50CQACAQMFBHBvb2wJAKwCAgkArAICCQCsAgIJAKwCAgIYQ2FuJ3Qgd2l0aGRyYXcgbmVnYXRpdmUgBQZBc3NldDECAS8FBkFzc2V0MgIHIGFtb3VudAIjQ2FuJ3Qgd2l0aGRyYXcgbmVnYXRpdmUgQXhBaSBhbW91bnQECW5ld0Ftb3VudAkAZQIFDWN1cnJlbnRBbW91bnQFBmFtb3VudAMJAGYCAAAFCW5ld0Ftb3VudAkAAgEDBQRwb29sCQCsAgIJAKwCAgkArAICCQCsAgICFE5vdCBlbm91Z2ggQXNzZXQgTHAgBQZBc3NldDECAS8FBkFzc2V0MgIIIGJhbGFuY2UCF05vdCBlbm91Z2ggQXhBaSBiYWxhbmNlCQDMCAIJAQxJbnRlZ2VyRW50cnkCAwUEcG9vbAkArAICCQCsAgIJAKwCAgIJU1RBS0VfTFBfBQpjdXJyZW50S2V5AgFfCQECa3ACBQZBc3NldDEFBkFzc2V0MgUKY3VycmVudEtleQUJbmV3QW1vdW50CQDMCAIJAQxJbnRlZ2VyRW50cnkCAwUEcG9vbAkArAICAhdUb3RhbF9Ub2tlbnNfTFBfTG9ja2VkXwkBAmtwAgUGQXNzZXQxBQZBc3NldDICFFRvdGFsX1Rva2Vuc19Mb2NrZWQ6BQp0b3RhbHRva2VuCQDMCAIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUGYW1vdW50AwUEcG9vbAkA2QQBCQERQGV4dHJOYXRpdmUoMTA1MykCBQR0aGlzCQCsAgIFAWwJAQJrcAIFBkFzc2V0MQUGQXNzZXQyCQEJTWFpbkFzc2V0AAkAzAgCCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFB2ZlZUNhbGMJAQlNYWluQXNzZXQACQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFB3Bvb2xLZXkCDl9yYXRlX2ZlZV9zd2FwCQBlAgUDb29kBQRvbGRUBQNuaWwJAAIBAilsaXF1aWRpdHkgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgkAAgECJGRBcHAgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgFpAQlDcmVhdGVORlQCBG5hbWUEaXBmcwQEc2hhaAkA9wMBCQDZBAEFBGlwZnMJAMwIAgkAwggFBQRuYW1lCQCsAgIJAKwCAgkArAICCQCsAgICCXsnaXBmcyc6JwUEaXBmcwIOJywnU0hBLUhBU0gnOicJANgEAQUEc2hhaAICJ30AAQAABwUDbmlsAWkBBkJ1eU5GVAEFTkZUSWQEBXBvd2VyCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUCYWMEBG5mdG0JARFAZXh0ck5hdGl2ZSgxMDUxKQIFBUFkbWluBQZuZmV0QWMEA3BtdAkAkQMCCAUBaQhwYXltZW50cwAABAVwcmljZQQHJG1hdGNoMAkBEUBleHRyTmF0aXZlKDEwNTApAgUEdGhpcwkArAICBQVORlRJZAIHX3Rvc2FsZQMJAAECBQckbWF0Y2gwAgNJbnQEAmlzBQckbWF0Y2gwBQJpcwAABAVhc3NldAQHJG1hdGNoMAkBEUBleHRyTmF0aXZlKDEwNTMpAgUEdGhpcwkArAICBQVORlRJZAIKX2Fzc2V0c2FsZQMJAAECBQckbWF0Y2gwAgZTdHJpbmcEAXMFByRtYXRjaDADAwkAAAIFAXMCBVdBVkVTBgkAAAIFAXMCBXdhdmVzBQVXQVZFUwkA2QQBBQFzCQACAQIXTkZUIG5vdCBsaXN0ZWQgZm9yIHNhbGUECm9sZEFkZHJlc3MEByRtYXRjaDAJARFAZXh0ck5hdGl2ZSgxMDUzKQIFBHRoaXMJAKwCAgUFTkZUSWQCCF9hZGRyZXNzAwkAAQIFByRtYXRjaDACBlN0cmluZwQBcwUHJG1hdGNoMAUBcwkAAgECF05GVCBub3QgbGlzdGVkIGZvciBzYWxlAwUFcG93ZXIDCQEBIQEFBG5mdG0DCQECIT0CBQVwcmljZQAAAwkAAAIFBXByaWNlCAUDcG10BmFtb3VudAMJAAACCAUDcG10B2Fzc2V0SWQFBWFzc2V0CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFBU5GVElkAgdfdG9zYWxlAAAJAMwIAgkBDEJvb2xlYW5FbnRyeQIJAKwCAgUFTkZUSWQCBl9zYWxlZAYJAMwIAgkBC1N0cmluZ0VudHJ5AgkArAICBQVORlRJZAINX2FkZHJlc3NfU0FsZQIACQDMCAIJAQtTdHJpbmdFbnRyeQIJAKwCAgUFTkZUSWQCCl9hc3NldHNhbGUFBU5GVElkCQDMCAIJAQtTdHJpbmdFbnRyeQIJAKwCAgUFTkZUSWQCCF9hZGRyZXNzCQDYBAEICAUBaQZjYWxsZXIFYnl0ZXMJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyAAEJANkEAQUFTkZUSWQJAMwIAgkBDlNjcmlwdFRyYW5zZmVyAwkBB0FkZHJlc3MBCQDZBAEFCm9sZEFkZHJlc3MIBQNwbXQGYW1vdW50BQVhc3NldAUDbmlsCQACAQJKQXNzZXQgbm90IGVxdWFsIHRvIHRoZSBhc3NldCBkZWZpbmVkIGFzIGEgcGF5bWVudCBtZXRob2QgYnkgdGhlIE5GVCBpc3N1ZXIJAAIBAh1WYWx1ZSBub3QgZXF1YWwgdG8gc2FsZSB2YWx1ZQkAAgECGVRoaXMgTkZUIGlzIG5vdCBmb3Igc2FsZS4JAAIBAiNORlQgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgkAAgECJGRBcHAgaXMgY3VycmVudGx5IHVuZGVyIG1haW50ZW5hbmNlLgFpAQxSZW1vdmVUb1NlbGwBBU5GVElkBAVwb3dlcgkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FAmFjBARuZnRtCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUGbmZldEFjBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAMFBXBvd2VyAwkBASEBBQRuZnRtAwkAAAIJARRnZXRBc3NldElzc3VlQWRkcmVzcwEJANkEAQUFTkZUSWQIBQFpBmNhbGxlcgkAzAgCCQELRGVsZXRlRW50cnkBCQCsAgIFBU5GVElkAgdfdG9zYWxlCQDMCAIJAQtEZWxldGVFbnRyeQEJAKwCAgUFTkZUSWQCBl9zYWxlZAkAzAgCCQELRGVsZXRlRW50cnkBCQCsAgIFBU5GVElkAg1fYWRkcmVzc19TQWxlCQDMCAIJAQtEZWxldGVFbnRyeQEJAKwCAgUFTkZUSWQCCl9hc3NldHNhbGUJAMwIAgkBC0RlbGV0ZUVudHJ5AQkArAICBQVORlRJZAIIX2FkZHJlc3MFA25pbAkAAgECNk9ubHkgdGhlIG93bmVyIG9mIHRoZSBORlQgY2FuIHJlbW92ZSBpdCBmcm9tIHRoZSBsaXN0LgkAAgECI05GVCBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuCQACAQIkZEFwcCBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuAWkBB1NlbGxORlQCBVByaWNlBWFzc2V0BAVwb3dlcgkBEUBleHRyTmF0aXZlKDEwNTEpAgUFQWRtaW4FAmFjBARuZnRtCQERQGV4dHJOYXRpdmUoMTA1MSkCBQVBZG1pbgUGbmZldEFjBANwbXQJAJEDAggFAWkIcGF5bWVudHMAAAMFBXBvd2VyAwkBASEBBQRuZnRtAwMJAAACCAUDcG10BmFtb3VudAAABgkAAAIIBQNwbXQHYXNzZXRJZAUFV0FWRVMJAAIBAipSZXF1aXJlcyBORlQgYXMgdHJhbnNmZXIgcGF5bWVudCBmb3Igc2FsZS4JAMwIAgkBDEludGVnZXJFbnRyeQIJAKwCAgkBCGdldEFzc2V0AQgFA3BtdAdhc3NldElkAgdfdG9zYWxlBQVQcmljZQkAzAgCCQEMQm9vbGVhbkVudHJ5AgkArAICCQEIZ2V0QXNzZXQBCAUDcG10B2Fzc2V0SWQCBl9zYWxlZAcJAMwIAgkBC1N0cmluZ0VudHJ5AgkArAICCQEIZ2V0QXNzZXQBCAUDcG10B2Fzc2V0SWQCDV9hZGRyZXNzX1NBbGUCAAkAzAgCCQELU3RyaW5nRW50cnkCCQCsAgIJAQhnZXRBc3NldAEIBQNwbXQHYXNzZXRJZAIKX2Fzc2V0c2FsZQUFYXNzZXQJAMwIAgkBC1N0cmluZ0VudHJ5AgkArAICCQEIZ2V0QXNzZXQBCAUDcG10B2Fzc2V0SWQCCF9hZGRyZXNzCQDYBAEICAUBaQZjYWxsZXIFYnl0ZXMFA25pbAkAAgECI05GVCBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuCQACAQIkZEFwcCBpcyBjdXJyZW50bHkgdW5kZXIgbWFpbnRlbmFuY2UuAWkBEENyZWF0ZUNvbGxlY3Rpb24BDmNvbGxlY3Rpb25OYW1lBApjdXJyZW50S2V5CQDYBAEICAUBaQZjYWxsZXIFYnl0ZXMEAnRjBAckbWF0Y2gwCQERQGV4dHJOYXRpdmUoMTA1MCkCBQR0aGlzCQCsAgIFCmN1cnJlbnRLZXkCEV90b3RhbF9jb2xsZWN0aW9uAwkAAQIFByRtYXRjaDACA0ludAQCYWkFByRtYXRjaDAFAmFpAAADCQEVdmVyaWZpQ29sbGVjdGlvbkV4aXN0AQUOY29sbGVjdGlvbk5hbWUJAAIBAkNFcnJvcjogQSBjb2xsZWN0aW9uIHdpdGggdGhhdCBuYW1lIGFscmVhZHkgZXhpc3RzLCB0cnkgYW5vdGhlciBvbmUuCQDMCAIJAQtTdHJpbmdFbnRyeQIFDmNvbGxlY3Rpb25OYW1lBQpjdXJyZW50S2V5CQDMCAIJAQxJbnRlZ2VyRW50cnkCCQCsAgIFCmN1cnJlbnRLZXkCEV90b3RhbF9jb2xsZWN0aW9uCQBkAgUCdGMAAQUDbmlsAQJ0eAEGdmVyaWZ5AAkA9AMDCAUCdHgJYm9keUJ5dGVzCQCRAwIIBQJ0eAZwcm9vZnMAAAgFAnR4D3NlbmRlclB1YmxpY0tleeWepNc=",
    "height": 2487445,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 5Jn3wXhXpmoKce1n3yALwz44ayyoBV8CTdeR2FwUksof
Next: none

Diff: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let adminAddress = "3PLVPoB6KsXCtqowhzWJStijNw7SjsPKsq6"
4
+
let adminAddress = "3N8UaqrCTjypGPWXSvFJVSLv23bfuiPoJAh"
5
5
 
6
6
 
let Admin = Address(fromBase58String(adminAddress))
7
7
 

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 6 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
-
let adminAddress = "3PLVPoB6KsXCtqowhzWJStijNw7SjsPKsq6"
4
+
let adminAddress = "3N8UaqrCTjypGPWXSvFJVSLv23bfuiPoJAh"
5
5
 
6
6
 
let Admin = Address(fromBase58String(adminAddress))
7
7
 
8
8
 
let waves = "WAVES"
9
9
 
10
10
 
let aWaves = "accept_waves"
11
11
 
12
12
 
let WAVES = unit
13
13
 
14
14
 
let nfetAc = "activate_nft"
15
15
 
16
16
 
let main = "main_asset"
17
17
 
18
18
 
let l = "lp_asset_"
19
19
 
20
20
 
let aa1 = "pool__"
21
21
 
22
22
 
let sa = "STAKING_AMOUNT_"
23
23
 
24
24
 
let la = "LEASE_AMOUNT_"
25
25
 
26
26
 
let ix = "ID_"
27
27
 
28
28
 
let rateFee = "percentage_rate_fee_swap"
29
29
 
30
30
 
let rateFeeLimit = "rate_fee_limit"
31
31
 
32
32
 
let rateFeeHeight = "rate_fee_height"
33
33
 
34
34
 
let deposit_height = "Deposit_Height_Of_"
35
35
 
36
36
 
let ac = "activate"
37
37
 
38
38
 
let poolAc = "activate_pools"
39
39
 
40
40
 
let swapAc = "activate_swap"
41
41
 
42
42
 
let liquidityAc = "activate_liquidity"
43
43
 
44
44
 
let bcD = "block_distribuition"
45
45
 
46
46
 
let D8 = pow(10, 0, 8, 0, 0, HALFUP)
47
47
 
48
48
 
let total_locked = "Total_Tokens_Locked_"
49
49
 
50
50
 
let iniError = "Smart contract admin has not yet been initialized."
51
51
 
52
52
 
func D (i) = value(assetInfo(i)).decimals
53
53
 
54
54
 
55
55
 
func dM (i,o) = pow(10, 0, (i - o), 0, 0, HALFUP)
56
56
 
57
57
 
58
58
 
func D10 (i) = pow(10, 0, value(assetInfo(i)).decimals, 0, 0, HALFUP)
59
59
 
60
60
 
61
61
 
func validateAsset (assetS,stringAsset,acWaves) = if (if ((assetS == WAVES))
62
62
 
    then (stringAsset == waves)
63
63
 
    else false)
64
64
 
    then if (acWaves)
65
65
 
        then true
66
66
 
        else throw("The smart contract does not currently support Waves.")
67
67
 
    else if ((assetS == fromBase58String(stringAsset)))
68
68
 
        then true
69
69
 
        else false
70
70
 
71
71
 
72
72
 
func getAsset (a) = match a {
73
73
 
    case a: ByteVector => 
74
74
 
        toBase58String(a)
75
75
 
    case _ => 
76
76
 
        throw("Requires NFT as payment for sale.")
77
77
 
}
78
78
 
79
79
 
80
80
 
func kp (asset1,asset2) = (((aa1 + asset1) + "_") + asset2)
81
81
 
82
82
 
83
83
 
func validPoolK (key) = match getInteger(this, key) {
84
84
 
    case i: Int => 
85
85
 
        i
86
86
 
    case _ => 
87
87
 
        false
88
88
 
}
89
89
 
90
90
 
91
91
 
func kpAddress (address,key) = match getInteger(this, ((key + "_") + address)) {
92
92
 
    case t: Int => 
93
93
 
        t
94
94
 
    case _ => 
95
95
 
        0
96
96
 
}
97
97
 
98
98
 
99
99
 
func poolAA (address,key,asset) = match getInteger(this, ((((address + "_") + key) + "_") + asset)) {
100
100
 
    case a: Int => 
101
101
 
        a
102
102
 
    case _ => 
103
103
 
        0
104
104
 
}
105
105
 
106
106
 
107
107
 
func assetP (key,asset) = match getInteger(this, ((key + "_") + asset)) {
108
108
 
    case a: Int => 
109
109
 
        a
110
110
 
    case _ => 
111
111
 
        1
112
112
 
}
113
113
 
114
114
 
115
115
 
func verifiCollectionExist (a) = match getStringValue(this, a) {
116
116
 
    case o: String => 
117
117
 
        true
118
118
 
    case _ => 
119
119
 
        false
120
120
 
}
121
121
 
122
122
 
123
123
 
func getAssetName (assetId) = match assetInfo(assetId) {
124
124
 
    case asset: Asset => 
125
125
 
        asset.name
126
126
 
    case _ => 
127
127
 
        throw("Can't find asset")
128
128
 
}
129
129
 
130
130
 
131
131
 
func getAssetIssueAddress (a) = match assetInfo(a) {
132
132
 
    case asset: Asset => 
133
133
 
        asset.issuer
134
134
 
    case _ => 
135
135
 
        throw("Can't find asset")
136
136
 
}
137
137
 
138
138
 
139
139
 
func totalAssetPool (key,assetLp) = match getInteger(this, key) {
140
140
 
    case a: Int => 
141
141
 
        a
142
142
 
    case _ => 
143
143
 
        if (assetLp)
144
144
 
            then D8
145
145
 
            else 1
146
146
 
}
147
147
 
148
148
 
149
149
 
func valid (assetPay,pair1,pair2) = {
150
150
 
    let pair1_58 = if ((pair1 == waves))
151
151
 
        then WAVES
152
152
 
        else fromBase58String(pair1)
153
153
 
    let pair2_58 = if ((pair2 == waves))
154
154
 
        then WAVES
155
155
 
        else fromBase58String(pair2)
156
156
 
    if ((assetPay == pair1_58))
157
157
 
        then pair2_58
158
158
 
        else pair1_58
159
159
 
    }
160
160
 
161
161
 
162
162
 
func pkey (Asset1,Asset2,address) = (((deposit_height + kp(Asset1, Asset2)) + "_") + address)
163
163
 
164
164
 
165
165
 
func getAmountBlockAsset (assetId) = match getInteger(this, assetId) {
166
166
 
    case i: Int => 
167
167
 
        i
168
168
 
    case _ => 
169
169
 
        0
170
170
 
}
171
171
 
172
172
 
173
173
 
func MainAsset () = fromBase58String(getStringValue(Admin, main))
174
174
 
175
175
 
176
176
 
func GetRateFeeSwap () = getIntegerValue(Admin, rateFee)
177
177
 
178
178
 
179
179
 
func lpBlocked (address,key) = match getInteger(this, ((("STAKE_LP_" + address) + "_") + key)) {
180
180
 
    case a: Int => 
181
181
 
        a
182
182
 
    case _ => 
183
183
 
        0
184
184
 
}
185
185
 
186
186
 
187
187
 
@Callable(i)
188
188
 
func Swap (Asset1,Asset2) = {
189
189
 
    let currentKey = toBase58String(i.caller.bytes)
190
190
 
    let acWaves = getBooleanValue(Admin, aWaves)
191
191
 
    let power = getBooleanValue(Admin, ac)
192
192
 
    let swapActivate = getBooleanValue(Admin, swapAc)
193
193
 
    let poolKey = kp(Asset1, Asset2)
194
194
 
    let key = validPoolK(poolKey)
195
195
 
    let asset1 = i.payments[0].assetId
196
196
 
    let asset2 = i.payments[1].assetId
197
197
 
    let lpAssetId = getIntegerValue(this, (l + kp(Asset1, Asset2)))
198
198
 
    let totalAsset1 = totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset1), false)
199
199
 
    let totalAsset2 = totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset2), false)
200
200
 
    let feeRatePercentual = getIntegerValue(Admin, rateFee)
201
201
 
    let prAsset1 = (toBigInt(i.payments[0].amount) * fraction(toBigInt(D8), toBigInt(totalAsset2), toBigInt(totalAsset1)))
202
202
 
    let priceAsset1 = toInt(((prAsset1 - ((prAsset1 / toBigInt(feeRatePercentual)) * toBigInt(100))) / toBigInt(D8)))
203
203
 
    let prAsset2 = (toBigInt(i.payments[0].amount) * fraction(toBigInt(D8), toBigInt(totalAsset1), toBigInt(totalAsset2)))
204
204
 
    let priceAsset2 = toInt(((prAsset2 - ((prAsset2 / toBigInt(feeRatePercentual)) * toBigInt(100))) / toBigInt(D8)))
205
205
 
    let sendValue = if (if ((asset1 == WAVES))
206
206
 
        then (Asset1 == waves)
207
207
 
        else false)
208
208
 
        then priceAsset1
209
209
 
        else if ((asset1 == fromBase58String(Asset1)))
210
210
 
            then priceAsset1
211
211
 
            else priceAsset2
212
212
 
    let assetUpdatePay = if ((asset1 == WAVES))
213
213
 
        then waves
214
214
 
        else if ((asset1 == fromBase58String(Asset1)))
215
215
 
            then Asset1
216
216
 
            else Asset2
217
217
 
    let assetUpdateSwap = if ((asset1 == WAVES))
218
218
 
        then waves
219
219
 
        else if ((asset1 == fromBase58String(Asset1)))
220
220
 
            then Asset2
221
221
 
            else Asset1
222
222
 
    let assetSendSwap = valid(i.payments[0].assetId, Asset1, Asset2)
223
223
 
    let n1s = (assetP(kp(Asset1, Asset2), assetUpdateSwap) - sendValue)
224
224
 
    let nw = (getAmountBlockAsset(assetUpdateSwap) - sendValue)
225
225
 
    let newUpda = if ((0 > n1s))
226
226
 
        then 0
227
227
 
        else n1s
228
228
 
    let newUpdateSwap = if ((0 > nw))
229
229
 
        then 0
230
230
 
        else nw
231
231
 
    let Dx =     match i.payments[0].assetId {
232
232
 
        case o: Unit => 
233
233
 
            pow(10, 0, 8, 0, 0, HALFUP)
234
234
 
        case x: ByteVector => 
235
235
 
            pow(10, 0, value(assetInfo(x)).decimals, 0, 0, HALFUP)
236
236
 
        case _ => 
237
237
 
            throw("Match error")
238
238
 
    }
239
239
 
    if (power)
240
240
 
        then if (!(swapActivate))
241
241
 
            then if (if (!((Asset1 == Asset2)))
242
242
 
                then if (validateAsset(asset1, Asset1, acWaves))
243
243
 
                    then true
244
244
 
                    else validateAsset(asset1, Asset2, acWaves)
245
245
 
                else false)
246
246
 
                then if ((key != false))
247
247
 
                    then if ((i.payments[1].assetId == MainAsset()))
248
248
 
                        then if ((i.payments[1].amount == GetRateFeeSwap()))
249
249
 
                            then if (if ((totalAsset1 > 2))
250
250
 
                                then true
251
251
 
                                else (totalAsset2 > 2))
252
252
 
                                then {
253
253
 
                                    let oldRateFeeSwapTotal =                                     match getInteger(this, (poolKey + "_rate_fee_swap")) {
254
254
 
                                        case o: Int => 
255
255
 
                                            (o + GetRateFeeSwap())
256
256
 
                                        case _ => 
257
257
 
                                            GetRateFeeSwap()
258
258
 
                                    }
259
259
 
[ScriptTransfer(Address(i.caller.bytes), if ((0 > sendValue))
260
260
 
                                        then Dx
261
261
 
                                        else sendValue, assetSendSwap), IntegerEntry(assetUpdateSwap, newUpdateSwap), IntegerEntry(((kp(Asset1, Asset2) + "_") + assetUpdateSwap), newUpda), IntegerEntry(((kp(Asset1, Asset2) + "_") + assetUpdatePay), (assetP(kp(Asset1, Asset2), assetUpdatePay) + i.payments[0].amount)), IntegerEntry(assetUpdatePay, (getAmountBlockAsset(assetUpdatePay) + i.payments[0].amount)), IntegerEntry(toBase58String(MainAsset()), (getAmountBlockAsset(toBase58String(MainAsset())) + i.payments[1].amount)), IntegerEntry((poolKey + "_rate_fee_swap"), oldRateFeeSwapTotal)]
262
262
 
                                    }
263
263
 
                                else throw("Pool has no liquidity.")
264
264
 
                            else throw((("Swap denied! " + toString(GetRateFeeSwap())) + " Bicon is required for the swap fee."))
265
265
 
                        else throw("Invalid rate asset")
266
266
 
                    else throw("Invalid Swap Key.")
267
267
 
                else throw("Asset1 cannot be equal to Asset2")
268
268
 
            else throw("Swap is currently under maintenance.")
269
269
 
        else throw("dApp is currently under maintenance.")
270
270
 
    }
271
271
 
272
272
 
273
273
 
274
274
 
@Callable(i)
275
275
 
func AddLiquidity (Asset1,Asset2) = {
276
276
 
    let power = getBooleanValue(Admin, ac)
277
277
 
    let poolActivate = getBooleanValue(Admin, poolAc)
278
278
 
    let acWaves = getBooleanValue(Admin, aWaves)
279
279
 
    let key = validPoolK(kp(Asset1, Asset2))
280
280
 
    let asset1 = i.payments[0].assetId
281
281
 
    let asset2 = i.payments[1].assetId
282
282
 
    let lpAssetId = getStringValue(this, (l + kp(Asset1, Asset2)))
283
283
 
    let totalAsset1Pool = if ((2 > totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset1), false)))
284
284
 
        then i.payments[0].amount
285
285
 
        else totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset1), false)
286
286
 
    let totalAsset2Pool = if ((2 > totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset1), false)))
287
287
 
        then i.payments[1].amount
288
288
 
        else totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset2), false)
289
289
 
    let totalLp = totalAssetPool(lpAssetId, true)
290
290
 
    let priceLpAsset = ((totalAsset1Pool + totalAsset2Pool) / totalLp)
291
291
 
    let quantityAsset2 = (i.payments[0].amount * (totalAsset2Pool / totalAsset1Pool))
292
292
 
    let rateTop = (i.payments[1].amount + ((i.payments[1].amount * 2) / 100))
293
293
 
    let rateBottom = (i.payments[1].amount - ((i.payments[1].amount * 2) / 100))
294
294
 
    let Validate = if (if (if ((i.payments[1].amount == quantityAsset2))
295
295
 
        then true
296
296
 
        else (rateTop > i.payments[1].amount))
297
297
 
        then true
298
298
 
        else (i.payments[1].amount > rateBottom))
299
299
 
        then true
300
300
 
        else false
301
301
 
    if (power)
302
302
 
        then if (!(poolActivate))
303
303
 
            then if (if (if (!((asset1 == asset2)))
304
304
 
                then validateAsset(asset1, Asset1, acWaves)
305
305
 
                else false)
306
306
 
                then validateAsset(asset2, Asset2, acWaves)
307
307
 
                else false)
308
308
 
                then if ((key != false))
309
309
 
                    then if (Validate)
310
310
 
                        then {
311
311
 
                            let currentKey = toBase58String(i.caller.bytes)
312
312
 
                            let currentAmount = kpAddress(currentKey, kp(Asset1, Asset2))
313
313
 
                            let currentAmountAsset1 = poolAA(currentKey, kp(Asset1, Asset2), Asset1)
314
314
 
                            let currentAmountAsset2 = poolAA(currentKey, kp(Asset1, Asset2), Asset2)
315
315
 
                            let asset1pool = assetP(kp(Asset1, Asset2), Asset1)
316
316
 
                            let asset2pool = assetP(kp(Asset1, Asset2), Asset2)
317
317
 
                            let receiveLp = if ((totalAsset1Pool == i.payments[0].amount))
318
318
 
                                then (1 * D8)
319
319
 
                                else toInt((((toBigInt(i.payments[0].amount) * toBigInt(D8)) + (toBigInt(i.payments[1].amount) * toBigInt(D8))) / (((toBigInt(totalAsset1Pool) * toBigInt(D8)) + (toBigInt(totalAsset2Pool) * toBigInt(D8))) / toBigInt(totalLp))))
320
320
 
                            let newcurrentAmountAsset1 = (currentAmountAsset1 + i.payments[0].amount)
321
321
 
                            let newcurrentAmountAsset2 = (currentAmountAsset2 + i.payments[1].amount)
322
322
 
                            let newcurrentAmount = (currentAmount + receiveLp)
323
323
 
                            let newasset1pool = (asset1pool + i.payments[0].amount)
324
324
 
                            let newasset2pool = (asset2pool + i.payments[1].amount)
325
325
 
[Reissue(fromBase58String(lpAssetId), receiveLp, true), ScriptTransfer(Address(i.caller.bytes), receiveLp, fromBase58String(lpAssetId)), IntegerEntry(pkey(Asset1, Asset2, currentKey), height), IntegerEntry(((((currentKey + "_") + kp(Asset1, Asset2)) + "_") + Asset1), newcurrentAmountAsset1), IntegerEntry(((((currentKey + "_") + kp(Asset1, Asset2)) + "_") + Asset2), newcurrentAmountAsset2), IntegerEntry(((kp(Asset1, Asset2) + "_") + currentKey), newcurrentAmount), IntegerEntry(((kp(Asset1, Asset2) + "_") + Asset1), newasset1pool), IntegerEntry(((kp(Asset1, Asset2) + "_") + Asset2), newasset2pool), IntegerEntry(Asset1, (getAmountBlockAsset(Asset1) + i.payments[0].amount)), IntegerEntry(Asset2, (getAmountBlockAsset(Asset2) + i.payments[1].amount)), IntegerEntry(lpAssetId, (getAmountBlockAsset(lpAssetId) + receiveLp))]
326
326
 
                            }
327
327
 
                        else throw(((((("Payment of invalid 1/1 amounts to the Pool. Try Asset2: {value:" + toString((i.payments[0].amount * (totalAsset2Pool / totalAsset1Pool)))) + "} Received: ") + toString(i.payments[1].amount)) + " Validate: ") + toString(Validate)))
328
328
 
                    else throw("Invalid Pool Key.")
329
329
 
                else throw("Asset1 cannot be equal to Asset2")
330
330
 
            else throw("liquidity is currently under maintenance.")
331
331
 
        else throw("dApp is currently under maintenance.")
332
332
 
    }
333
333
 
334
334
 
335
335
 
336
336
 
@Callable(i)
337
337
 
func ActivatePool (asset1,asset2,Name,customName) = {
338
338
 
    let nameAsset1 = if ((asset1 == waves))
339
339
 
        then waves
340
340
 
        else getAssetName(fromBase58String(asset1))
341
341
 
    let nameAsset2 = if ((asset2 == waves))
342
342
 
        then waves
343
343
 
        else getAssetName(fromBase58String(asset2))
344
344
 
    let name = if (customName)
345
345
 
        then Name
346
346
 
        else ((nameAsset1 + "_") + nameAsset2)
347
347
 
    let key = validPoolK(kp(asset1, asset2))
348
348
 
    if ((i.caller == getAssetIssueAddress(fromBase58String(asset1))))
349
349
 
        then if ((key != false))
350
350
 
            then {
351
351
 
                let assetLpCreate = Issue(name, ((("LP asset for pool liquidity in Bicon DEX pair " + asset1) + "_") + asset2), (1 * D8), 8, true)
352
352
 
                let idAssetLp = calculateAssetId(assetLpCreate)
353
353
 
[StringEntry((l + kp(asset1, asset2)), toBase58String(idAssetLp)), assetLpCreate]
354
354
 
                }
355
355
 
            else throw("Invalid Pool Key. Try inverting the assets")
356
356
 
        else throw("Only the issuer address of asset1 itself can invoke this function.")
357
357
 
    }
358
358
 
359
359
 
360
360
 
361
361
 
@Callable(i)
362
362
 
func RemoveLiquidity (Asset1,Asset2,Amount) = {
363
363
 
    let currentKey = toBase58String(i.caller.bytes)
364
364
 
    let power = getBooleanValue(Admin, ac)
365
365
 
    let poolActivate = getBooleanValue(Admin, poolAc)
366
366
 
    let acWaves = getBooleanValue(Admin, aWaves)
367
367
 
    let poolKey = kp(Asset1, Asset2)
368
368
 
    let key = validPoolK(poolKey)
369
369
 
    let asset1 = if ((Asset1 == waves))
370
370
 
        then if (acWaves)
371
371
 
            then WAVES
372
372
 
            else throw("The smart contract does not currently support Waves.")
373
373
 
        else fromBase58String(Asset1)
374
374
 
    let asset2 = if ((Asset2 == waves))
375
375
 
        then if (acWaves)
376
376
 
            then WAVES
377
377
 
            else throw("The smart contract does not currently support Waves.")
378
378
 
        else fromBase58String(Asset2)
379
379
 
    let lpAssetId = getStringValue(this, (l + kp(Asset1, Asset2)))
380
380
 
    let currentAmount = kpAddress(currentKey, kp(Asset1, Asset2))
381
381
 
    let amountLpBlocked = lpBlocked(currentKey, poolKey)
382
382
 
    let totalLP = totalAssetPool(lpAssetId, true)
383
383
 
    let totalAsset1Pool = totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset1), false)
384
384
 
    let totalAsset2Pool = totalAssetPool(((kp(Asset1, Asset2) + "_") + Asset2), false)
385
385
 
    if (power)
386
386
 
        then if (!(poolActivate))
387
387
 
            then if (!((Asset1 == Asset2)))
388
388
 
                then if ((key != false))
389
389
 
                    then if (!((currentAmount == 0)))
390
390
 
                        then if (((currentAmount - amountLpBlocked) >= Amount))
391
391
 
                            then if (if ((totalAsset1Pool > 2))
392
392
 
                                then true
393
393
 
                                else (totalAsset2Pool > 2))
394
394
 
                                then {
395
395
 
                                    let receiveAsset1 = (toInt(((fraction(toBigInt(i.payments[0].amount), toBigInt(D8), toBigInt(totalLP)) * toBigInt(totalAsset1Pool)) / toBigInt(D8))) - 1)
396
396
 
                                    let receiveAsset2 = (toInt(((fraction(toBigInt(i.payments[0].amount), toBigInt(D8), toBigInt(totalLP)) * toBigInt(totalAsset2Pool)) / toBigInt(D8))) - 1)
397
397
 
                                    let asset1pool = assetP(kp(Asset1, Asset2), Asset1)
398
398
 
                                    let asset2pool = assetP(kp(Asset1, Asset2), Asset2)
399
399
 
                                    let currentAmountAsset1 = poolAA(currentKey, kp(Asset1, Asset2), Asset1)
400
400
 
                                    let currentAmountAsset2 = poolAA(currentKey, kp(Asset1, Asset2), Asset2)
401
401
 
                                    let newcurrentAmountAsset1 = (currentAmountAsset1 - receiveAsset1)
402
402
 
                                    let newcurrentAmountAsset2 = (currentAmountAsset2 - receiveAsset2)
403
403
 
                                    let newcurrentAmount = (currentAmount - Amount)
404
404
 
                                    let newasset1pool = (asset1pool - receiveAsset1)
405
405
 
                                    let newasset2pool = (asset2pool - receiveAsset2)
406
406
 
                                    if ((i.payments[0].assetId == fromBase58String(lpAssetId)))
407
407
 
                                        then if ((Amount == i.payments[0].amount))
408
408
 
                                            then [Burn(fromBase58String(lpAssetId), Amount), ScriptTransfer(Address(i.caller.bytes), receiveAsset1, asset1), ScriptTransfer(Address(i.caller.bytes), receiveAsset2, asset2), IntegerEntry(pkey(Asset1, Asset2, currentKey), height), IntegerEntry(((((currentKey + "_") + kp(Asset1, Asset2)) + "_") + Asset1), newcurrentAmountAsset1), IntegerEntry(((((currentKey + "_") + kp(Asset1, Asset2)) + "_") + Asset2), newcurrentAmountAsset2), IntegerEntry(((kp(Asset1, Asset2) + "_") + currentKey), newcurrentAmount), IntegerEntry(((kp(Asset1, Asset2) + "_") + Asset1), newasset1pool), IntegerEntry(((kp(Asset1, Asset2) + "_") + Asset2), newasset2pool), IntegerEntry(Asset1, (getAmountBlockAsset(Asset1) - receiveAsset1)), IntegerEntry(Asset2, (getAmountBlockAsset(Asset2) - receiveAsset2)), IntegerEntry(lpAssetId, (getAmountBlockAsset(lpAssetId) - Amount))]
409
409
 
                                            else throw(("Withdrawal amount lower than asset lp amount. Your Lp amount available: " + toString(Amount)))
410
410
 
                                        else throw("Requires an lp asset as payment to remove locked amounts.")
411
411
 
                                    }
412
412
 
                                else throw("Pool has no liquidity.")
413
413
 
                            else throw(("Amount to be withdrawn greater than the amount available for withdrawal. Available: " + toString(Amount)))
414
414
 
                        else throw("You have no locked values ​​in the pool")
415
415
 
                    else throw("Invalid Pool Key.")
416
416
 
                else throw("Asset1 cannot be equal to Asset2")
417
417
 
            else throw("liquidity is currently under maintenance.")
418
418
 
        else throw("dApp is currently under maintenance.")
419
419
 
    }
420
420
 
421
421
 
422
422
 
423
423
 
@Callable(i)
424
424
 
func Stake (pool,Asset1,Asset2) = {
425
425
 
    let power = getBooleanValue(Admin, ac)
426
426
 
    let liquidityPower = getBooleanValue(Admin, liquidityAc)
427
427
 
    let lpAssetId = if (pool)
428
428
 
        then getStringValue(Admin, (l + kp(Asset1, Asset2)))
429
429
 
        else MainAsset()
430
430
 
    let lpAId =     match lpAssetId {
431
431
 
        case xi: String => 
432
432
 
            fromBase58String(xi)
433
433
 
        case x: ByteVector => 
434
434
 
            x
435
435
 
        case _ => 
436
436
 
            throw("Match error")
437
437
 
    }
438
438
 
    if (power)
439
439
 
        then if (!(liquidityPower))
440
440
 
            then if ((i.payments[0].assetId != lpAId))
441
441
 
                then throw((("Invalid asset! Kindly Deposit Only " + toBase58String(MainAsset())) + " or valid asset lp"))
442
442
 
                else if (!(pool))
443
443
 
                    then {
444
444
 
                        let currentKey = toBase58String(i.caller.bytes)
445
445
 
                        let currentAmount =                         match getInteger(this, currentKey) {
446
446
 
                            case a: Int => 
447
447
 
                                a
448
448
 
                            case _ => 
449
449
 
                                0
450
450
 
                        }
451
451
 
                        let h = if ((currentAmount == 0))
452
452
 
                            then height
453
453
 
                            else valueOrElse(getIntegerValue(this, (deposit_height + currentKey)), height)
454
454
 
                        let newAmount = (currentAmount + i.payments[0].amount)
455
455
 
                        let useramount = IntegerEntry(currentKey, newAmount)
456
456
 
                        let userdepositheight = IntegerEntry((deposit_height + currentKey), h)
457
457
 
                        let previouslockbalance =                         match getInteger(this, "Total_Tokens_Locked:") {
458
458
 
                            case a: Int => 
459
459
 
                                a
460
460
 
                            case _ => 
461
461
 
                                0
462
462
 
                        }
463
463
 
                        let totaltoken = (previouslockbalance + i.payments[0].amount)
464
464
 
                        let TLV = IntegerEntry("Total_Tokens_Locked:", totaltoken)
465
465
 
[useramount, userdepositheight, TLV]
466
466
 
                        }
467
467
 
                    else {
468
468
 
                        let poolKey = kp(Asset1, Asset2)
469
469
 
                        let key = validPoolK(poolKey)
470
470
 
                        if ((key != false))
471
471
 
                            then {
472
472
 
                                let currentKey = toBase58String(i.caller.bytes)
473
473
 
                                let currentAmount =                                 match getInteger(this, ((("STAKE_LP_" + currentKey) + "_") + poolKey)) {
474
474
 
                                    case a: Int => 
475
475
 
                                        a
476
476
 
                                    case _ => 
477
477
 
                                        0
478
478
 
                                }
479
479
 
                                let h = if ((currentAmount == 0))
480
480
 
                                    then height
481
481
 
                                    else valueOrElse(getIntegerValue(this, ((((deposit_height + "_") + currentKey) + "_") + poolKey)), height)
482
482
 
                                let newAmount = (currentAmount + i.payments[0].amount)
483
483
 
                                let useramount = IntegerEntry(((("STAKE_LP_" + currentKey) + "_") + poolKey), newAmount)
484
484
 
                                let userdepositheight = IntegerEntry(((((deposit_height + "_") + currentKey) + "_") + poolKey), height)
485
485
 
                                let previouslockbalance =                                 match getInteger(this, ("Total_Tokens_LP_Locked_" + poolKey)) {
486
486
 
                                    case a: Int => 
487
487
 
                                        a
488
488
 
                                    case _ => 
489
489
 
                                        0
490
490
 
                                }
491
491
 
                                let totaltoken = (previouslockbalance + i.payments[0].amount)
492
492
 
                                let TLV = IntegerEntry(("Total_Tokens_LP_Locked_" + poolKey), totaltoken)
493
493
 
[useramount, userdepositheight, TLV]
494
494
 
                                }
495
495
 
                            else throw("Invalid Pool key.")
496
496
 
                        }
497
497
 
            else throw("liquidity is currently under maintenance.")
498
498
 
        else throw("dApp is currently under maintenance.")
499
499
 
    }
500
500
 
501
501
 
502
502
 
503
503
 
@Callable(i)
504
504
 
func Unstake (pool,Asset1,Asset2,amount) = {
505
505
 
    let power = getBooleanValue(Admin, ac)
506
506
 
    let liquidityPower = getBooleanValue(Admin, liquidityAc)
507
507
 
    let poolKey = kp(Asset1, Asset2)
508
508
 
    let pmt = i.payments[0]
509
509
 
    if (power)
510
510
 
        then if (!(liquidityPower))
511
511
 
            then {
512
512
 
                let currentKey = toBase58String(i.caller.bytes)
513
513
 
                let currentAmount =                 match if (pool)
514
514
 
                        then getIntegerValue(this, ((("STAKE_LP_" + currentKey) + "_") + kp(Asset1, Asset2)))
515
515
 
                        else getIntegerValue(this, currentKey) {
516
516
 
                    case a: Int => 
517
517
 
                        a
518
518
 
                    case _ => 
519
519
 
                        0
520
520
 
                }
521
521
 
                let swapheightkeyname = if (pool)
522
522
 
                    then ((((deposit_height + "_") + currentKey) + "_") + kp(Asset1, Asset2))
523
523
 
                    else (deposit_height + currentKey)
524
524
 
                let previouslockbalance = if (pool)
525
525
 
                    then getIntegerValue(this, ("Total_Tokens_LP_Locked_" + kp(Asset1, Asset2)))
526
526
 
                    else getIntegerValue(this, "Total_Tokens_Locked:")
527
527
 
                let totaltoken = (previouslockbalance - amount)
528
528
 
                let diff = (height - getIntegerValue(this, swapheightkeyname))
529
529
 
                let bcd = getIntegerValue(this, bcD)
530
530
 
                let reward = ((diff * bcd) * D8)
531
531
 
                let ood =                 match getInteger((poolKey + "_rate_fee_swap")) {
532
532
 
                    case iw: Int => 
533
533
 
                        iw
534
534
 
                    case _ => 
535
535
 
                        0
536
536
 
                }
537
537
 
                let oldT =                 match getInteger((poolKey + "_rate_fee_swap")) {
538
538
 
                    case idd: Int => 
539
539
 
                        (idd / (previouslockbalance / amount))
540
540
 
                    case _ => 
541
541
 
                        0
542
542
 
                }
543
543
 
                let feeCalc = if ((Asset1 == getStringValue(this, main)))
544
544
 
                    then (reward / (previouslockbalance / amount))
545
545
 
                    else oldT
546
546
 
                if ((0 > amount))
547
547
 
                    then throw(if (pool)
548
548
 
                        then (((("Can't withdraw negative " + Asset1) + "/") + Asset2) + " amount")
549
549
 
                        else "Can't withdraw negative AxAi amount")
550
550
 
                    else {
551
551
 
                        let newAmount = (currentAmount - amount)
552
552
 
                        if ((0 > newAmount))
553
553
 
                            then throw(if (pool)
554
554
 
                                then (((("Not enough Asset Lp " + Asset1) + "/") + Asset2) + " balance")
555
555
 
                                else "Not enough AxAi balance")
556
556
 
                            else [IntegerEntry(if (pool)
557
557
 
                                then ((("STAKE_LP_" + currentKey) + "_") + kp(Asset1, Asset2))
558
558
 
                                else currentKey, newAmount), IntegerEntry(if (pool)
559
559
 
                                then ("Total_Tokens_LP_Locked_" + kp(Asset1, Asset2))
560
560
 
                                else "Total_Tokens_Locked:", totaltoken), ScriptTransfer(i.caller, amount, if (pool)
561
561
 
                                then fromBase58String(getStringValue(this, (l + kp(Asset1, Asset2))))
562
562
 
                                else MainAsset()), ScriptTransfer(i.caller, feeCalc, MainAsset()), IntegerEntry((poolKey + "_rate_fee_swap"), (ood - oldT))]
563
563
 
                        }
564
564
 
                }
565
565
 
            else throw("liquidity is currently under maintenance.")
566
566
 
        else throw("dApp is currently under maintenance.")
567
567
 
    }
568
568
 
569
569
 
570
570
 
571
571
 
@Callable(i)
572
572
 
func CreateNFT (name,ipfs) = {
573
573
 
    let shah = sha256(fromBase58String(ipfs))
574
574
 
[Issue(name, (((("{'ipfs':'" + ipfs) + "','SHA-HASH':'") + toBase58String(shah)) + "'}"), 1, 0, false)]
575
575
 
    }
576
576
 
577
577
 
578
578
 
579
579
 
@Callable(i)
580
580
 
func BuyNFT (NFTId) = {
581
581
 
    let power = getBooleanValue(Admin, ac)
582
582
 
    let nftm = getBooleanValue(Admin, nfetAc)
583
583
 
    let pmt = i.payments[0]
584
584
 
    let price =     match getIntegerValue(this, (NFTId + "_tosale")) {
585
585
 
        case is: Int => 
586
586
 
            is
587
587
 
        case _ => 
588
588
 
            0
589
589
 
    }
590
590
 
    let asset =     match getStringValue(this, (NFTId + "_assetsale")) {
591
591
 
        case s: String => 
592
592
 
            if (if ((s == "WAVES"))
593
593
 
                then true
594
594
 
                else (s == "waves"))
595
595
 
                then WAVES
596
596
 
                else fromBase58String(s)
597
597
 
        case _ => 
598
598
 
            throw("NFT not listed for sale")
599
599
 
    }
600
600
 
    let oldAddress =     match getStringValue(this, (NFTId + "_address")) {
601
601
 
        case s: String => 
602
602
 
            s
603
603
 
        case _ => 
604
604
 
            throw("NFT not listed for sale")
605
605
 
    }
606
606
 
    if (power)
607
607
 
        then if (!(nftm))
608
608
 
            then if ((price != 0))
609
609
 
                then if ((price == pmt.amount))
610
610
 
                    then if ((pmt.assetId == asset))
611
611
 
                        then [IntegerEntry((NFTId + "_tosale"), 0), BooleanEntry((NFTId + "_saled"), true), StringEntry((NFTId + "_address_SAle"), ""), StringEntry((NFTId + "_assetsale"), NFTId), StringEntry((NFTId + "_address"), toBase58String(i.caller.bytes)), ScriptTransfer(i.caller, 1, fromBase58String(NFTId)), ScriptTransfer(Address(fromBase58String(oldAddress)), pmt.amount, asset)]
612
612
 
                        else throw("Asset not equal to the asset defined as a payment method by the NFT issuer")
613
613
 
                    else throw("Value not equal to sale value")
614
614
 
                else throw("This NFT is not for sale.")
615
615
 
            else throw("NFT is currently under maintenance.")
616
616
 
        else throw("dApp is currently under maintenance.")
617
617
 
    }
618
618
 
619
619
 
620
620
 
621
621
 
@Callable(i)
622
622
 
func RemoveToSell (NFTId) = {
623
623
 
    let power = getBooleanValue(Admin, ac)
624
624
 
    let nftm = getBooleanValue(Admin, nfetAc)
625
625
 
    let pmt = i.payments[0]
626
626
 
    if (power)
627
627
 
        then if (!(nftm))
628
628
 
            then if ((getAssetIssueAddress(fromBase58String(NFTId)) == i.caller))
629
629
 
                then [DeleteEntry((NFTId + "_tosale")), DeleteEntry((NFTId + "_saled")), DeleteEntry((NFTId + "_address_SAle")), DeleteEntry((NFTId + "_assetsale")), DeleteEntry((NFTId + "_address"))]
630
630
 
                else throw("Only the owner of the NFT can remove it from the list.")
631
631
 
            else throw("NFT is currently under maintenance.")
632
632
 
        else throw("dApp is currently under maintenance.")
633
633
 
    }
634
634
 
635
635
 
636
636
 
637
637
 
@Callable(i)
638
638
 
func SellNFT (Price,asset) = {
639
639
 
    let power = getBooleanValue(Admin, ac)
640
640
 
    let nftm = getBooleanValue(Admin, nfetAc)
641
641
 
    let pmt = i.payments[0]
642
642
 
    if (power)
643
643
 
        then if (!(nftm))
644
644
 
            then if (if ((pmt.amount == 0))
645
645
 
                then true
646
646
 
                else (pmt.assetId == WAVES))
647
647
 
                then throw("Requires NFT as transfer payment for sale.")
648
648
 
                else [IntegerEntry((getAsset(pmt.assetId) + "_tosale"), Price), BooleanEntry((getAsset(pmt.assetId) + "_saled"), false), StringEntry((getAsset(pmt.assetId) + "_address_SAle"), ""), StringEntry((getAsset(pmt.assetId) + "_assetsale"), asset), StringEntry((getAsset(pmt.assetId) + "_address"), toBase58String(i.caller.bytes))]
649
649
 
            else throw("NFT is currently under maintenance.")
650
650
 
        else throw("dApp is currently under maintenance.")
651
651
 
    }
652
652
 
653
653
 
654
654
 
655
655
 
@Callable(i)
656
656
 
func CreateCollection (collectionName) = {
657
657
 
    let currentKey = toBase58String(i.caller.bytes)
658
658
 
    let tc =     match getIntegerValue(this, (currentKey + "_total_collection")) {
659
659
 
        case ai: Int => 
660
660
 
            ai
661
661
 
        case _ => 
662
662
 
            0
663
663
 
    }
664
664
 
    if (verifiCollectionExist(collectionName))
665
665
 
        then throw("Error: A collection with that name already exists, try another one.")
666
666
 
        else [StringEntry(collectionName, currentKey), IntegerEntry((currentKey + "_total_collection"), (tc + 1))]
667
667
 
    }
668
668
 
669
669
 
670
670
 
@Verifier(tx)
671
671
 
func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
672
672
 

github/deemru/w8io/169f3d6 
64.23 ms ◑