w8 · tx · 8jK···iA6

tx · 8jKD68yjCcXXkBQjusT8gMB6KnkQ6rJKhpUGzSTeziA6

3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH:  -0.01400000 Waves

2022.07.26 16:00 [2156796] smart account 3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "8jKD68yjCcXXkBQjusT8gMB6KnkQ6rJKhpUGzSTeziA6",
    "fee": 1400000,
    "feeAssetId": null,
    "timestamp": 1658840419911,
    "version": 2,
    "chainId": 84,
    "sender": "3N8n6BtTBKRZBoPuMzaPBH9FyJhfv9xDFJH",
    "senderPublicKey": "4hcnYaYoB2XaCzyJ7wfePpG7EfTd6st6aCAhkskJ9cQ5",
    "proofs": [
        "5JDvFvnRp6343sZa5xGsKRt1bLLJaR9NtLsEqdbZ4SUq9mX35oUnaUS6izAr4oevPVfypBGMEnEk2Yaq1twgQqN1"
    ],
    "script": "base64:BgIeCAISABIAEgASABIAEgASABIAEgASABIAEgASABIAHQAKdXNkdFVzZG5MUAEg202DNWRHG5bvnwwvoM991XmdkujhmzUPwT/MewJwKQsADXVzZHRVc2RuTFBUQ0kBIAqBzantQGEdmEq4Oth6BGhTCCbAyZjxYcEpfvod3iryAAh3eFVzZG5MUAEgG7mhj3vOTKXN+s5HyQsWjk32W97C65PB1sWo0bGqCxwAC3d4VXNkbkxQVENJASC37N3mGwJ72rYTh/1V0NY8tseiNz1LiL3Be29IRACYLwAKdXNkY1VzZG5MUAEgA2kB/BsKmAqIzY/+EVmFhSaRMrNakvwm6Uhd05/eXHYADXVzZGNVc2RuTFBUQ0kBIPYCN93Tn++GRS9cI0cPlV/ROm2hK8KntJtUQQdS9W7GAAp1c2RjVXNkdExQASDG+KR0G1ZIVhCfkH7CM/Qxa4sESiwr/ZlLh/WFm3zkjAANdXNkY1VzZHRMUFRDSQEgAsaFfARLM8fi74dnh1L7VYL9s9+EI7agWsU13c9XSv4ADHB1enpsZVVzZG5MUAEgwzPGdM4jqqQi30kk5cSZa3gEsHdWgnT/uNEdSo0c0Z4AD3B1enpsZVVzZG5MUFRDSQEgvJT6zwcHAR1Xf2NHmqYN/fUF18bEe85zWm98KZKIR7UABHd4SWQBIJMBHKupx24lV85mnnG2vapr+DzoWAsq7tmgTrs83BSxAA5rZXlTcG9uc29yc2hpcAITU3BvbnNvcnNoaXBfaW5fbG9jawAJaXNTdG9wcGVkBwAJa2V5U3Rha2VkAglTVEFLRURfTFAAC2tleUNvbXBvdW5kAg1Gcm9tX0NvbXBvdW5kABFrZXl3eFVzZG5Db21wb3VuZAIQV1hfVVNETl9jb21wb3VuZAAJa2V5V1hVU0ROAgdXWF9VU0ROABNrZXlVc2RjVXNkbkNvbXBvdW5kAhJVU0RDX1VTRE5fY29tcG91bmQAC2tleVVTRENVU0ROAglVU0RDX1VTRE4AE2tleVVzZGNVc2R0Q29tcG91bmQCElVTRENfVVNEVF9jb21wb3VuZAALa2V5VVNEQ1VTRFQCCVVTRENfVVNEVAAVa2V5UHV6emxlVXNkbkNvbXBvdW5kAhRQVVpaTEVfVVNETl9jb21wb3VuZAANa2V5UFVaWkxFVVNETgILUFVaWkxFX1VTRE4AA2RlZgCAwtcvAAdmZWVQZXJjAIDIr6AlAAJ0dwEaAVREB1pAb+J/pyN/gYjTyGw4FQkpHHvIQAIABm9yYWNsZQEaAVThpQZGwrspHkLD7S7yKY9anhD69jC7CuAACXN0YWtlUG9vbAIjM014M3ptWHJNY0xGQ2FmTXVQdFhBelI0WlBWZVpZYjZxTHoBDGNoZWNrQWRkcmVzcwEGY2FsbGVyAwkBAiE9AgUGY2FsbGVyBQZvcmFjbGUHBg4BaQEMaW5pdFVzZHRVc2RuAAQCcG0JAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQCYW0IBQJwbQZhbW91bnQDCQECIT0CCAUCcG0HYXNzZXRJZAUKdXNkdFVzZG5MUAkAAgECEFVuZXhwZWN0ZWQgdG9rZW4EAXMJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIFc3Rha2UFA25pbAkAzAgCBQJwbQUDbmlsAwkAAAIFAXMFAXMEA3VwZAkBDEludGVnZXJFbnRyeQIFCWtleVN0YWtlZAUCYW0EBHVwZEsJAQxJbnRlZ2VyRW50cnkCBQtrZXlDb21wb3VuZAAACQDMCAIFA3VwZAkAzAgCBQR1cGRLBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEId2l0aGRyYXcABAdwYXltZW50CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAAEAmFtCAUHcGF5bWVudAZhbW91bnQEAmlkCAUHcGF5bWVudAdhc3NldElkAwkAAAIFAmlkBQ11c2R0VXNkbkxQVENJBAlUQ0lBbW91bnQEByRtYXRjaDAJAOwHAQUNdXNkdFVzZG5MUFRDSQMJAAECBQckbWF0Y2gwAgVBc3NldAQBcQUHJG1hdGNoMAgFAXEIcXVhbnRpdHkAAAQOdXNkblVzZHRTdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUJa2V5U3Rha2VkAAAEDGZvclNpbmdsZVRDSQkAawMFDnVzZG5Vc2R0U3Rha2VkBQNkZWYFCVRDSUFtb3VudAQQdXNkbkxwVG9XaXRoZHJhdwkAawMFDGZvclNpbmdsZVRDSQUCYW0FA2RlZgQHdW5zdGFrZQkA/AcECQEHQWRkcmVzcwEBGgFUWUAnk2tLKe6+saEO5txAuM+kjXoM67UPAgd1bnN0YWtlCQDMCAICLEZtNHFjenU2UGVwejhLVWhoM0hlYjZMZVRWZnBTTVg1dnZOZ3czeDc2NENTCQDMCAIFEHVzZG5McFRvV2l0aGRyYXcFA25pbAUDbmlsAwkAAAIFB3Vuc3Rha2UFB3Vuc3Rha2UEA2ZlZQkAawMFEHVzZG5McFRvV2l0aGRyYXcFA2RlZgUHZmVlUGVyYwQDYnJuCQEEQnVybgIFDXVzZHRVc2RuTFBUQ0kFAmFtAwkAAAIFA2JybgUDYnJuBBJ1cGRhdGVVc2RuTHBTdGFrZWQJAQxJbnRlZ2VyRW50cnkCBQlrZXlTdGFrZWQJAGUCBQ51c2RuVXNkdFN0YWtlZAUQdXNkbkxwVG9XaXRoZHJhdwQRdXNkbkxwZmVlVHJhbnNmZXIJAQ5TY3JpcHRUcmFuc2ZlcgMJAQdBZGRyZXNzAQUCdHcFA2ZlZQUKdXNkdFVzZG5MUAQIdHJhbnNmZXIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgkAZQIFEHVzZG5McFRvV2l0aGRyYXcFA2ZlZQUKdXNkdFVzZG5MUAkAzAgCBRF1c2RuTHBmZWVUcmFuc2ZlcgkAzAgCBQh0cmFuc2ZlcgkAzAgCBRJ1cGRhdGVVc2RuTHBTdGFrZWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgMJAAACBQJpZAULd3hVc2RuTFBUQ0kEB3d4VGNpQW0EByRtYXRjaDAJAOwHAQULd3hVc2RuTFBUQ0kDCQABAgUHJG1hdGNoMAIFQXNzZXQEAXEFByRtYXRjaDAIBQFxCHF1YW50aXR5AAAEDHd4VXNkblN0YWtlZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQlrZXlXWFVTRE4AAAQKc2luZ2xlV1hMUAkAawMFDHd4VXNkblN0YWtlZAUDZGVmBQd3eFRjaUFtBA53eExwVG9XaXRoZHJhdwkAawMFCnNpbmdsZVdYTFAFAmFtBQNkZWYEA2ZlZQkAawMFDnd4THBUb1dpdGhkcmF3BQNkZWYFB2ZlZVBlcmMEB3Vuc3Rha2UJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIHdW5zdGFrZQkAzAgCAiwyc0VCVmN5REZLMkx1cENmN01lQTR2ekhoR0s0REMxV2piS0dRQ0xZRHFpYgkAzAgCBQ53eExwVG9XaXRoZHJhdwUDbmlsBQNuaWwDCQAAAgUHdW5zdGFrZQUHdW5zdGFrZQQPd3hMcEZlZVRyYW5zZmVyCQEOU2NyaXB0VHJhbnNmZXIDCQEHQWRkcmVzcwEFAnR3BQNmZWUFCHd4VXNkbkxQBAx3eExwVHJhbnNmZXIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgkAZQIFAmFtBQNmZWUFCHd4VXNkbkxQBBB1cGRhdGVXeExwU3Rha2VkCQEMSW50ZWdlckVudHJ5AgUJa2V5V1hVU0ROCQBlAgUMd3hVc2RuU3Rha2VkBQ53eExwVG9XaXRoZHJhdwQLYnVybld4THBUY2kJAQRCdXJuAgUId3hVc2RuTFAFAmFtAwkAAAIFC2J1cm5XeExwVGNpBQtidXJuV3hMcFRjaQkAzAgCBQ93eExwRmVlVHJhbnNmZXIJAMwIAgUMd3hMcFRyYW5zZmVyCQDMCAIFEHVwZGF0ZVd4THBTdGFrZWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgMJAAACBQJpZAUNdXNkY1VzZG5MUFRDSQQLdXNkY1VzZG5UQ0kEByRtYXRjaDAJAOwHAQUNdXNkY1VzZG5MUFRDSQMJAAECBQckbWF0Y2gwAgVBc3NldAQBcQUHJG1hdGNoMAgFAXEIcXVhbnRpdHkAAAQOdXNkY1VzZG5TdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwULa2V5VVNEQ1VTRE4AAAQMc2luZ2xlVXNkY0xQCQBrAwULdXNkY1VzZG5UQ0kFA2RlZgUOdXNkY1VzZG5TdGFrZWQEEHVzZGNMcFRvV2l0aGRyYXcJAGsDBQxzaW5nbGVVc2RjTFAFAmFtBQNkZWYEA2ZlZQkAawMFEHVzZGNMcFRvV2l0aGRyYXcFA2RlZgUHZmVlUGVyYwQNdXNkY1VzZG5MUEZlZQkBDlNjcmlwdFRyYW5zZmVyAwkBB0FkZHJlc3MBBQJ0dwUDZmVlBQp1c2RjVXNkbkxQBBB1c2RjVXNkblRyYW5zZmVyCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIJAGUCBQJhbQUDZmVlBQp1c2RjVXNkbkxQBBZ1cGRhdGVVc2RjVXNkbkxwU3Rha2VkCQEMSW50ZWdlckVudHJ5AgULa2V5VVNEQ1VTRE4JAGUCBQ51c2RjVXNkblN0YWtlZAUQdXNkY0xwVG9XaXRoZHJhdwQRYnVyblVzZGNVc2RuTHBUY2kJAQRCdXJuAgUNdXNkY1VzZG5MUFRDSQUCYW0DCQAAAgURYnVyblVzZGNVc2RuTHBUY2kFEWJ1cm5Vc2RjVXNkbkxwVGNpCQDMCAIFDXVzZGNVc2RuTFBGZWUJAMwIAgUQdXNkY1VzZG5UcmFuc2ZlcgkAzAgCBRZ1cGRhdGVVc2RjVXNkbkxwU3Rha2VkBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4DCQAAAgUCaWQFDXVzZGNVc2R0TFBUQ0kEC3VzZGNVc2R0VGNpBAckbWF0Y2gwCQDsBwEFDXVzZGNVc2RuTFBUQ0kDCQABAgUHJG1hdGNoMAIFQXNzZXQEAXEFByRtYXRjaDAIBQFxCHF1YW50aXR5AAAEDnVzZGNVc2R0U3Rha2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFC2tleVVTRENVU0RUAAAEDnNpbmdsZVVzZGNVc2R0CQBrAwULdXNkY1VzZHRUY2kFA2RlZgUOdXNkY1VzZHRTdGFrZWQEFHVzZGNVc2R0THBUb1dpdGhkcmF3CQBrAwUOc2luZ2xlVXNkY1VzZHQFAmFtBQNkZWYEA2ZlZQkAawMFFHVzZGNVc2R0THBUb1dpdGhkcmF3BQNkZWYFB2ZlZVBlcmMEDXVzZGNVc2R0TFBGZWUJAQ5TY3JpcHRUcmFuc2ZlcgMJAQdBZGRyZXNzAQUCdHcFA2ZlZQUKdXNkY1VzZHRMUAQQdXNkY1VzZHRUcmFuc2ZlcgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyCQBlAgUCYW0FA2ZlZQUKdXNkY1VzZHRMUAQWdXBkYXRlVXNkY1VzZHRMcFN0YWtlZAkBDEludGVnZXJFbnRyeQIFC2tleVVTRENVU0RUCQBlAgUOdXNkY1VzZHRTdGFrZWQFFHVzZGNVc2R0THBUb1dpdGhkcmF3BAtidXJuV3hMcFRjaQkBBEJ1cm4CBQ11c2RjVXNkbkxQVENJBQJhbQMJAAACBQtidXJuV3hMcFRjaQULYnVybld4THBUY2kJAMwIAgUNdXNkY1VzZHRMUEZlZQkAzAgCBRB1c2RjVXNkdFRyYW5zZmVyCQDMCAIFFnVwZGF0ZVVzZGNVc2R0THBTdGFrZWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgMJAAACBQJpZAUPcHV6emxlVXNkbkxQVENJBA1wdXp6bGVVc2RuVGNpBAckbWF0Y2gwCQDsBwEFD3B1enpsZVVzZG5MUFRDSQMJAAECBQckbWF0Y2gwAgVBc3NldAQBcQUHJG1hdGNoMAgFAXEIcXVhbnRpdHkAAAQOcHV6emxlTFBTdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUNa2V5UFVaWkxFVVNETgAABBBzaW5nbGVQdXp6bGVVc2RuCQBrAwUNcHV6emxlVXNkblRjaQUDZGVmBQ5wdXp6bGVMUFN0YWtlZAQScHV6emxlVXNkbldpdGhkcmF3CQBrAwUQc2luZ2xlUHV6emxlVXNkbgUCYW0FA2RlZgQDZmVlCQBrAwUScHV6emxlVXNkbldpdGhkcmF3BQNkZWYFB2ZlZVBlcmMED3B1enpsZVVzZG5MUEZlZQkBDlNjcmlwdFRyYW5zZmVyAwkBB0FkZHJlc3MBBQJ0dwUDZmVlBQxwdXp6bGVVc2RuTFAEEnB1enpsZVVzZG5UcmFuc2ZlcgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyCQBlAgUCYW0FA2ZlZQUMcHV6emxlVXNkbkxQBBh1cGRhdGVQdXp6bGVVc2RuTHBTdGFrZWQJAQxJbnRlZ2VyRW50cnkCBQ1rZXlQVVpaTEVVU0ROCQBlAgUOcHV6emxlTFBTdGFrZWQFEnB1enpsZVVzZG5XaXRoZHJhdwQNYnVyblB1enpsZVRDSQkBBEJ1cm4CBQ9wdXp6bGVVc2RuTFBUQ0kFAmFtAwkAAAIFDWJ1cm5QdXp6bGVUQ0kFDWJ1cm5QdXp6bGVUQ0kJAMwIAgUPcHV6emxlVXNkbkxQRmVlCQDMCAIFEnB1enpsZVVzZG5UcmFuc2ZlcgkAzAgCBRh1cGRhdGVQdXp6bGVVc2RuTHBTdGFrZWQFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAgECDUludmFsaWQgYXNzZXQBaQEPZGVwb3NpdFd4VXNkbkxQAAQDcG10CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAAECXBtdEFtb3VudAgFA3BtdAZhbW91bnQDCQECIT0CCAUDcG10B2Fzc2V0SWQFCHd4VXNkbkxQCQACAQIbYXR0YWNoIFdYVVNETkxQIHRva2VucyBvbmx5AwUJaXNTdG9wcGVkCQACAQIZc21hcnQgY29udHJhY3QgaXMgb24gbG9jawQIdGtTdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUJa2V5V1hVU0ROAAAEC3RvdGFsSXNzdWVkBAckbWF0Y2gwCQDsBwEFC3d4VXNkbkxQVENJAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0CHF1YW50aXR5CQACAQIQQ2FuJ3QgZmluZCBhc3NldAQDb25lCQBrAwULdG90YWxJc3N1ZWQAgMLXLwUIdGtTdGFrZWQEB3RvSXNzdWUJAGsDBQlwbXRBbW91bnQFA29uZQCAwtcvBAt1cGRhdGVTdGF0ZQkBDEludGVnZXJFbnRyeQIFCWtleVdYVVNETgkAZAIFCHRrU3Rha2VkBQlwbXRBbW91bnQEB0xQc3Rha2UJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIFc3Rha2UFA25pbAkAzAgCBQNwbXQFA25pbAMJAAACBQdMUHN0YWtlBQdMUHN0YWtlBAdMUElzc3VlCQEHUmVpc3N1ZQMFC3d4VXNkbkxQVENJBQd0b0lzc3VlBgQIdHJhbnNmZXIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUHdG9Jc3N1ZQULd3hVc2RuTFBUQ0kJAMwIAgUHTFBJc3N1ZQkAzAgCBQh0cmFuc2ZlcgkAzAgCBQt1cGRhdGVTdGF0ZQUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBEWRlcG9zaXRVc2R0VXNkbkxQAAQDcG10CQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAAECXBtdEFtb3VudAgFA3BtdAZhbW91bnQDCQECIT0CCAUDcG10B2Fzc2V0SWQFCnVzZHRVc2RuTFAJAAIBAh1hdHRhY2ggVVNEVFVTRE5MUCB0b2tlbnMgb25seQMFCWlzU3RvcHBlZAkAAgECGXNtYXJ0IGNvbnRyYWN0IGlzIG9uIGxvY2sECHRrU3Rha2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFCWtleVN0YWtlZAAABAt0b3RhbElzc3VlZAQHJG1hdGNoMAkA7AcBBQ11c2R0VXNkbkxQVENJAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0CHF1YW50aXR5CQACAQIQQ2FuJ3QgZmluZCBhc3NldAQMZnJvbUNvbXBvdW5kCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFC2tleUNvbXBvdW5kAAAEBmZvck9uZQkAawMFC3RvdGFsSXNzdWVkAIDC1y8FCHRrU3Rha2VkBAd0b0lzc3VlCQBrAwUJcG10QW1vdW50BQZmb3JPbmUAgMLXLwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQlrZXlTdGFrZWQJAGQCBQh0a1N0YWtlZAUJcG10QW1vdW50BAdMUHN0YWtlCQD8BwQJAQdBZGRyZXNzAQEaAVRZQCeTa0sp7r6xoQ7m3EC4z6SNegzrtQ8CBXN0YWtlBQNuaWwJAMwIAgUDcG10BQNuaWwDCQAAAgUHTFBzdGFrZQUHTFBzdGFrZQQHTFBJc3N1ZQkBB1JlaXNzdWUDBQ11c2R0VXNkbkxQVENJBQd0b0lzc3VlBgQIdHJhbnNmZXIJAQ5TY3JpcHRUcmFuc2ZlcgMIBQFpBmNhbGxlcgUHdG9Jc3N1ZQUNdXNkdFVzZG5MUFRDSQkAzAgCBQdMUElzc3VlCQDMCAIFCHRyYW5zZmVyCQDMCAIFC3VwZGF0ZVN0YXRlBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQERZGVwb3NpdFVzZGNVc2RuTFAABANwbXQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQJcG10QW1vdW50CAUDcG10BmFtb3VudAMJAQIhPQIIBQNwbXQHYXNzZXRJZAUKdXNkY1VzZG5MUAkAAgECHWF0dGFjaCBVU0RDVVNETkxQIHRva2VucyBvbmx5AwUJaXNTdG9wcGVkCQACAQIZc21hcnQgY29udHJhY3QgaXMgb24gbG9jawQIdGtTdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwULa2V5VVNEQ1VTRE4AAAQLdG90YWxJc3N1ZWQEByRtYXRjaDAJAOwHAQUNdXNkY1VzZG5MUFRDSQMJAAECBQckbWF0Y2gwAgVBc3NldAQFYXNzZXQFByRtYXRjaDAIBQVhc3NldAhxdWFudGl0eQkAAgECEENhbid0IGZpbmQgYXNzZXQEDGZyb21Db21wb3VuZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBRNrZXlVc2RjVXNkbkNvbXBvdW5kAAAEBmZvck9uZQkAawMFC3RvdGFsSXNzdWVkAIDC1y8FCHRrU3Rha2VkBAd0b0lzc3VlCQBrAwUJcG10QW1vdW50BQZmb3JPbmUAgMLXLwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQtrZXlVU0RDVVNETgkAZAIFCHRrU3Rha2VkBQlwbXRBbW91bnQEB0xQc3Rha2UJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIFc3Rha2UFA25pbAkAzAgCBQNwbXQFA25pbAMJAAACBQdMUHN0YWtlBQdMUHN0YWtlBAdMUElzc3VlCQEHUmVpc3N1ZQMFDXVzZGNVc2RuTFBUQ0kFB3RvSXNzdWUGBAh0cmFuc2ZlcgkBDlNjcmlwdFRyYW5zZmVyAwgFAWkGY2FsbGVyBQd0b0lzc3VlBQ11c2RjVXNkbkxQVENJCQDMCAIFB0xQSXNzdWUJAMwIAgUIdHJhbnNmZXIJAMwIAgULdXBkYXRlU3RhdGUFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARFkZXBvc2l0VXNkY1VzZHRMUAAEA3BtdAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAlwbXRBbW91bnQIBQNwbXQGYW1vdW50AwkBAiE9AggFA3BtdAdhc3NldElkBQp1c2RjVXNkdExQCQACAQIdYXR0YWNoIFVTRENVU0RUTFAgdG9rZW5zIG9ubHkDBQlpc1N0b3BwZWQJAAIBAhlzbWFydCBjb250cmFjdCBpcyBvbiBsb2NrBAh0a1N0YWtlZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQtrZXlVU0RDVVNEVAAABAt0b3RhbElzc3VlZAQHJG1hdGNoMAkA7AcBBQ11c2RjVXNkdExQVENJAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0CHF1YW50aXR5CQACAQIQQ2FuJ3QgZmluZCBhc3NldAQMZnJvbUNvbXBvdW5kCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFE2tleVVzZGNVc2R0Q29tcG91bmQAAAQGZm9yT25lCQBrAwULdG90YWxJc3N1ZWQAgMLXLwUIdGtTdGFrZWQEB3RvSXNzdWUJAGsDBQlwbXRBbW91bnQFBmZvck9uZQCAwtcvBAt1cGRhdGVTdGF0ZQkBDEludGVnZXJFbnRyeQIFC2tleVVTRENVU0RUCQBkAgUIdGtTdGFrZWQFCXBtdEFtb3VudAQHTFBzdGFrZQkA/AcECQEHQWRkcmVzcwEBGgFUWUAnk2tLKe6+saEO5txAuM+kjXoM67UPAgVzdGFrZQUDbmlsCQDMCAIFA3BtdAUDbmlsAwkAAAIFB0xQc3Rha2UFB0xQc3Rha2UEB0xQSXNzdWUJAQdSZWlzc3VlAwUNdXNkY1VzZHRMUFRDSQUHdG9Jc3N1ZQYECHRyYW5zZmVyCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFB3RvSXNzdWUFDXVzZGNVc2R0TFBUQ0kJAMwIAgUHTFBJc3N1ZQkAzAgCBQh0cmFuc2ZlcgkAzAgCBQt1cGRhdGVTdGF0ZQUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBE2RlcG9zaXRQdXp6bGVVc2RuTFAABANwbXQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQJcG10QW1vdW50CAUDcG10BmFtb3VudAMJAQIhPQIIBQNwbXQHYXNzZXRJZAUMcHV6emxlVXNkbkxQCQACAQIfYXR0YWNoIFBVWlpMRVVEU05MUCB0b2tlbnMgb25seQMFCWlzU3RvcHBlZAkAAgECGXNtYXJ0IGNvbnRyYWN0IGlzIG9uIGxvY2sECHRrU3Rha2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFDWtleVBVWlpMRVVTRE4AAAQLdG90YWxJc3N1ZWQEByRtYXRjaDAJAOwHAQUPcHV6emxlVXNkbkxQVENJAwkAAQIFByRtYXRjaDACBUFzc2V0BAVhc3NldAUHJG1hdGNoMAgFBWFzc2V0CHF1YW50aXR5CQACAQIQQ2FuJ3QgZmluZCBhc3NldAQMZnJvbUNvbXBvdW5kCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFFWtleVB1enpsZVVzZG5Db21wb3VuZAAABAZmb3JPbmUJAGsDBQt0b3RhbElzc3VlZACAwtcvBQh0a1N0YWtlZAQHdG9Jc3N1ZQkAawMFCXBtdEFtb3VudAUGZm9yT25lAIDC1y8EC3VwZGF0ZVN0YXRlCQEMSW50ZWdlckVudHJ5AgUNa2V5UFVaWkxFVVNETgkAZAIFCHRrU3Rha2VkBQlwbXRBbW91bnQEB0xQc3Rha2UJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIFc3Rha2UFA25pbAkAzAgCBQNwbXQFA25pbAMJAAACBQdMUHN0YWtlBQdMUHN0YWtlBAdMUElzc3VlCQEHUmVpc3N1ZQMFD3B1enpsZVVzZG5MUFRDSQUHdG9Jc3N1ZQYECHRyYW5zZmVyCQEOU2NyaXB0VHJhbnNmZXIDCAUBaQZjYWxsZXIFB3RvSXNzdWUFD3B1enpsZVVzZG5MUFRDSQkAzAgCBQdMUElzc3VlCQDMCAIFCHRyYW5zZmVyCQDMCAIFC3VwZGF0ZVN0YXRlBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQEQY29tcG91bmRXeFVzZG5MUAAECGNvbXBvdW5kCQEFdmFsdWUBCQCRAwIIBQFpCHBheW1lbnRzAAAEAmNhCAUIY29tcG91bmQGYW1vdW50BAhpc09yYWNsZQkBDGNoZWNrQWRkcmVzcwEICAUBaQZjYWxsZXIFYnl0ZXMDCQECIT0CCAUIY29tcG91bmQHYXNzZXRJZAUId3hVc2RuTFAJAAIBAhthdHRhY2ggV1hVU0ROTFAgdG9rZW5zIG9ubHkDCQEBIQEFCGlzT3JhY2xlCQACAQIsWW91IGFyZSBub3QgYXV0aG90aXplZCB0byBjYWxsIHRoaXMgZnVuY3Rpb24EDGZyb21Db21wb3VuZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBRFrZXl3eFVzZG5Db21wb3VuZAAABAt0b3RhbFN0YWtlZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQlrZXlXWFVTRE4AAAQGc3Rha2VDCQD8BwQJAQdBZGRyZXNzAQEaAVRZQCeTa0sp7r6xoQ7m3EC4z6SNegzrtQ8CBXN0YWtlBQNuaWwJAMwIAgUIY29tcG91bmQFA25pbAMJAAACBQZzdGFrZUMFBnN0YWtlQwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQlrZXlXWFVTRE4JAGQCBQt0b3RhbFN0YWtlZAUCY2EEAnRjCQEMSW50ZWdlckVudHJ5AgURa2V5d3hVc2RuQ29tcG91bmQJAGQCBQxmcm9tQ29tcG91bmQFAmNhCQDMCAIFC3VwZGF0ZVN0YXRlCQDMCAIFAnRjBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQESY29tcG91bmRVc2R0VXNkbkxQAAQIY29tcG91bmQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQCY2EIBQhjb21wb3VuZAZhbW91bnQECGlzT3JhY2xlCQEMY2hlY2tBZGRyZXNzAQgIBQFpBmNhbGxlcgVieXRlcwMJAQIhPQIIBQhjb21wb3VuZAdhc3NldElkBQp1c2R0VXNkbkxQCQACAQIdYXR0YWNoIFVTRFRVU0ROTFAgdG9rZW5zIG9ubHkDCQEBIQEFCGlzT3JhY2xlCQACAQIsWW91IGFyZSBub3QgYXV0aG90aXplZCB0byBjYWxsIHRoaXMgZnVuY3Rpb24EDGZyb21Db21wb3VuZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQtrZXlDb21wb3VuZAAABAt0b3RhbFN0YWtlZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBQlrZXlTdGFrZWQAAAQGc3Rha2VDCQD8BwQJAQdBZGRyZXNzAQEaAVRZQCeTa0sp7r6xoQ7m3EC4z6SNegzrtQ8CBXN0YWtlBQNuaWwJAMwIAgUIY29tcG91bmQFA25pbAMJAAACBQZzdGFrZUMFBnN0YWtlQwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQlrZXlTdGFrZWQJAGQCBQt0b3RhbFN0YWtlZAUCY2EEAnRjCQEMSW50ZWdlckVudHJ5AgULa2V5Q29tcG91bmQJAGQCBQxmcm9tQ29tcG91bmQFAmNhCQDMCAIFC3VwZGF0ZVN0YXRlCQDMCAIFAnRjBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BaQESY29tcG91bmRVc2RjVXNkbkxQAAQIY29tcG91bmQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQCY2EIBQhjb21wb3VuZAZhbW91bnQECGlzT3JhY2xlCQEMY2hlY2tBZGRyZXNzAQgIBQFpBmNhbGxlcgVieXRlcwMJAQIhPQIIBQhjb21wb3VuZAdhc3NldElkBQp1c2RjVXNkbkxQCQACAQIdYXR0YWNoIFVTRENVU0ROTFAgdG9rZW5zIG9ubHkDCQEBIQEFCGlzT3JhY2xlCQACAQIsWW91IGFyZSBub3QgYXV0aG90aXplZCB0byBjYWxsIHRoaXMgZnVuY3Rpb24EDGZyb21Db21wb3VuZAkBC3ZhbHVlT3JFbHNlAgkAmggCBQR0aGlzBRNrZXlVc2RjVXNkbkNvbXBvdW5kAAAEC3RvdGFsU3Rha2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFC2tleVVTRENVU0ROAAAEBnN0YWtlQwkA/AcECQEHQWRkcmVzcwEBGgFUWUAnk2tLKe6+saEO5txAuM+kjXoM67UPAgVzdGFrZQUDbmlsCQDMCAIFCGNvbXBvdW5kBQNuaWwDCQAAAgUGc3Rha2VDBQZzdGFrZUMEC3VwZGF0ZVN0YXRlCQEMSW50ZWdlckVudHJ5AgULa2V5VVNEQ1VTRE4JAGQCBQt0b3RhbFN0YWtlZAUCY2EEAnRjCQEMSW50ZWdlckVudHJ5AgUTa2V5VXNkY1VzZG5Db21wb3VuZAkAZAIFDGZyb21Db21wb3VuZAUCY2EJAMwIAgULdXBkYXRlU3RhdGUJAMwIAgUCdGMFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpARJjb21wb3VuZFVzZGNVc2R0TFAABAhjb21wb3VuZAkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAJjYQgFCGNvbXBvdW5kBmFtb3VudAQIaXNPcmFjbGUJAQxjaGVja0FkZHJlc3MBCAgFAWkGY2FsbGVyBWJ5dGVzAwkBAiE9AggFCGNvbXBvdW5kB2Fzc2V0SWQFCnVzZGNVc2R0TFAJAAIBAh1hdHRhY2ggVVNEQ1VTRFRMUCB0b2tlbnMgb25seQMJAQEhAQUIaXNPcmFjbGUJAAIBAixZb3UgYXJlIG5vdCBhdXRob3RpemVkIHRvIGNhbGwgdGhpcyBmdW5jdGlvbgQMZnJvbUNvbXBvdW5kCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFE2tleVVzZGNVc2R0Q29tcG91bmQAAAQLdG90YWxTdGFrZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwULa2V5VVNEQ1VTRFQAAAQGc3Rha2VDCQD8BwQJAQdBZGRyZXNzAQEaAVRZQCeTa0sp7r6xoQ7m3EC4z6SNegzrtQ8CBXN0YWtlBQNuaWwJAMwIAgUIY29tcG91bmQFA25pbAMJAAACBQZzdGFrZUMFBnN0YWtlQwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQtrZXlVU0RDVVNEVAkAZAIFC3RvdGFsU3Rha2VkBQJjYQQCdGMJAQxJbnRlZ2VyRW50cnkCBRNrZXlVc2RjVXNkdENvbXBvdW5kCQBkAgUMZnJvbUNvbXBvdW5kBQJjYQkAzAgCBQt1cGRhdGVTdGF0ZQkAzAgCBQJ0YwUDbmlsCQACAQIkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAWkBFGNvbXBvdW5kUHV6emxlVXNkbkxQAAQIY29tcG91bmQJAQV2YWx1ZQEJAJEDAggFAWkIcGF5bWVudHMAAAQCY2EIBQhjb21wb3VuZAZhbW91bnQECGlzT3JhY2xlCQEMY2hlY2tBZGRyZXNzAQgIBQFpBmNhbGxlcgVieXRlcwMJAQIhPQIIBQhjb21wb3VuZAdhc3NldElkBQxwdXp6bGVVc2RuTFAJAAIBAh9hdHRhY2ggUFVaWkxFVVNETkxQIHRva2VucyBvbmx5AwkBASEBBQhpc09yYWNsZQkAAgECLFlvdSBhcmUgbm90IGF1dGhvdGl6ZWQgdG8gY2FsbCB0aGlzIGZ1bmN0aW9uBAxmcm9tQ29tcG91bmQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUVa2V5UHV6emxlVXNkbkNvbXBvdW5kAAAEC3RvdGFsU3Rha2VkCQELdmFsdWVPckVsc2UCCQCaCAIFBHRoaXMFDWtleVBVWlpMRVVTRE4AAAQGc3Rha2VDCQD8BwQJAQdBZGRyZXNzAQEaAVRZQCeTa0sp7r6xoQ7m3EC4z6SNegzrtQ8CBXN0YWtlBQNuaWwJAMwIAgUIY29tcG91bmQFA25pbAMJAAACBQZzdGFrZUMFBnN0YWtlQwQLdXBkYXRlU3RhdGUJAQxJbnRlZ2VyRW50cnkCBQ1rZXlQVVpaTEVVU0ROCQBkAgULdG90YWxTdGFrZWQFAmNhBAJ0YwkBDEludGVnZXJFbnRyeQIFFWtleVB1enpsZVVzZG5Db21wb3VuZAkAZAIFDGZyb21Db21wb3VuZAUCY2EJAMwIAgULdXBkYXRlU3RhdGUJAMwIAgUCdGMFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQxzcG9uc29yQm9vc3QABAJwbQkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABApsb2NrUGVyaW9kAGQDCQECIT0CCAUCcG0HYXNzZXRJZAUEd3hJZAkAAgECBUVycm9yBAlzcG9uc29yZWQJAQt2YWx1ZU9yRWxzZQIJAJoIAgUEdGhpcwUOa2V5U3BvbnNvcnNoaXAAAAQEbG9jawkA/AcECQEHQWRkcmVzcwEBGgFXs+bmVRgRabDkMw+IUUOknK7W1UsDSxFYAgxpbmNyZWFzZUxvY2sJAMwIAgUKbG9ja1BlcmlvZAUDbmlsCQDMCAIFAnBtBQNuaWwDCQAAAgUEbG9jawUEbG9jawQBcwkBDEludGVnZXJFbnRyeQIFDmtleVNwb25zb3JzaGlwCQBkAggFAnBtBmFtb3VudAUJc3BvbnNvcmVkCQDMCAIFAXMFA25pbAkAAgECJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgFpAQZpbml0V1gABAJwbQkBBXZhbHVlAQkAkQMCCAUBaQhwYXltZW50cwAABAJhbQgFAnBtBmFtb3VudAMJAQIhPQIIBQJwbQdhc3NldElkBQh3eFVzZG5MUAkAAgECEFVuZXhwZWN0ZWQgdG9rZW4EAXMJAPwHBAkBB0FkZHJlc3MBARoBVFlAJ5NrSynuvrGhDubcQLjPpI16DOu1DwIFc3Rha2UFA25pbAkAzAgCBQJwbQUDbmlsAwkAAAIFAXMFAXMEA3VwZAkBDEludGVnZXJFbnRyeQIFCWtleVdYVVNETgUCYW0EBHVwZEsJAQxJbnRlZ2VyRW50cnkCBRFrZXl3eFVzZG5Db21wb3VuZAAACQDMCAIFA3VwZAkAzAgCBQR1cGRLBQNuaWwJAAIBAiRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4BAnR4AQZ2ZXJpZnkACQD0AwMIBQJ0eAlib2R5Qnl0ZXMJAJEDAggFAnR4BnByb29mcwAACAUCdHgPc2VuZGVyUHVibGljS2V5nu9YPA==",
    "height": 2156796,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 4p27Ei2LgoqxkPStNyzyNjY31RfgTN88R341B365bt4U
Next: 4dK6LQXF53babiLS5PGLb2if2X2bSHTN7kkst4rRvJF7

Diff: 
Old New Differences
99 99              let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100 100              let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101 101              let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], nil)
102 -             let fee = fraction(usdnLpToWithdraw, def, feePerc)
103 -             let brn = Burn(usdtUsdnLPTCI, am)
104 -             if ((brn == brn))
102 +             if ((unstake == unstake))
105 103                  then {
106 -                     let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
107 -                     let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
108 -                     let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
104 +                     let fee = fraction(usdnLpToWithdraw, def, feePerc)
105 +                     let brn = Burn(usdtUsdnLPTCI, am)
106 +                     if ((brn == brn))
107 +                         then {
108 +                             let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
109 +                             let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
110 +                             let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
109 111  [usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
112 +                             }
113 +                         else throw("Strict value is not equal to itself.")
110 114                      }
111 115                  else throw("Strict value is not equal to itself.")
112 116              }
Full: 
Old New Differences
1 1  {-# STDLIB_VERSION 6 #-}
2 2  {-# SCRIPT_TYPE ACCOUNT #-}
3 3  {-# CONTENT_TYPE DAPP #-}
4 4  let usdtUsdnLP = base58'Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS'
5 5  
6 6  let usdtUsdnLPTCI = base58'i1snzKxSEZVokh9TWj8hTJQEDBsocnL2hRWsSbsMPK7'
7 7  
8 8  let wxUsdnLP = base58'2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib'
9 9  
10 10  let wxUsdnLPTCI = base58'DNy6WBfhPE4y82RonGdHhZEunNotEDzmNfrBomWnsyGi'
11 11  
12 12  let usdcUsdnLP = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
13 13  
14 14  let usdcUsdnLPTCI = base58'HZKFpNfyPG5gt4D6Nfy1zQSg2Ptmqv932GjNTCyBEeKP'
15 15  
16 16  let usdcUsdtLP = base58'EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH'
17 17  
18 18  let usdcUsdtLPTCI = base58'BqPYkaiz7Le6fFu1rjZ54anrpT57EpvyugZCUqrsjXj'
19 19  
20 20  let puzzleUsdnLP = base58'E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP'
21 21  
22 22  let puzzleUsdnLPTCI = base58'Dh9QXSSABE5V6aRfu3mCbDAUokbpE7ER7pbZV6cvyg1A'
23 23  
24 24  let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25 25  
26 26  let keySponsorship = "Sponsorship_in_lock"
27 27  
28 28  let isStopped = false
29 29  
30 30  let keyStaked = "STAKED_LP"
31 31  
32 32  let keyCompound = "From_Compound"
33 33  
34 34  let keywxUsdnCompound = "WX_USDN_compound"
35 35  
36 36  let keyWXUSDN = "WX_USDN"
37 37  
38 38  let keyUsdcUsdnCompound = "USDC_USDN_compound"
39 39  
40 40  let keyUSDCUSDN = "USDC_USDN"
41 41  
42 42  let keyUsdcUsdtCompound = "USDC_USDT_compound"
43 43  
44 44  let keyUSDCUSDT = "USDC_USDT"
45 45  
46 46  let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
47 47  
48 48  let keyPUZZLEUSDN = "PUZZLE_USDN"
49 49  
50 50  let def = 100000000
51 51  
52 52  let feePerc = 10000000000
53 53  
54 54  let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55 55  
56 56  let oracle = base58'3NAVBWBnqieKa3CdN39MAhToyTHShYxX1gB'
57 57  
58 58  let stakePool = "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz"
59 59  
60 60  func checkAddress (caller) = if ((caller != oracle))
61 61      then false
62 62      else true
63 63  
64 64  
65 65  @Callable(i)
66 66  func initUsdtUsdn () = {
67 67      let pm = value(i.payments[0])
68 68      let am = pm.amount
69 69      if ((pm.assetId != usdtUsdnLP))
70 70          then throw("Unexpected token")
71 71          else {
72 72              let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
73 73              if ((s == s))
74 74                  then {
75 75                      let upd = IntegerEntry(keyStaked, am)
76 76                      let updK = IntegerEntry(keyCompound, 0)
77 77  [upd, updK]
78 78                      }
79 79                  else throw("Strict value is not equal to itself.")
80 80              }
81 81      }
82 82  
83 83  
84 84  
85 85  @Callable(i)
86 86  func withdraw () = {
87 87      let payment = value(i.payments[0])
88 88      let am = payment.amount
89 89      let id = payment.assetId
90 90      if ((id == usdtUsdnLPTCI))
91 91          then {
92 92              let TCIAmount =             match assetInfo(usdtUsdnLPTCI) {
93 93                  case q: Asset => 
94 94                      q.quantity
95 95                  case _ => 
96 96                      0
97 97              }
98 98              let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
99 99              let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100 100              let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101 101              let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], nil)
102 -             let fee = fraction(usdnLpToWithdraw, def, feePerc)
103 -             let brn = Burn(usdtUsdnLPTCI, am)
104 -             if ((brn == brn))
102 +             if ((unstake == unstake))
105 103                  then {
106 -                     let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
107 -                     let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
108 -                     let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
104 +                     let fee = fraction(usdnLpToWithdraw, def, feePerc)
105 +                     let brn = Burn(usdtUsdnLPTCI, am)
106 +                     if ((brn == brn))
107 +                         then {
108 +                             let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
109 +                             let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
110 +                             let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
109 111  [usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
112 +                             }
113 +                         else throw("Strict value is not equal to itself.")
110 114                      }
111 115                  else throw("Strict value is not equal to itself.")
112 116              }
113 117          else if ((id == wxUsdnLPTCI))
114 118              then {
115 119                  let wxTciAm =                 match assetInfo(wxUsdnLPTCI) {
116 120                      case q: Asset => 
117 121                          q.quantity
118 122                      case _ => 
119 123                          0
120 124                  }
121 125                  let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
122 126                  let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
123 127                  let wxLpToWithdraw = fraction(singleWXLP, am, def)
124 128                  let fee = fraction(wxLpToWithdraw, def, feePerc)
125 129                  let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib", wxLpToWithdraw], nil)
126 130                  if ((unstake == unstake))
127 131                      then {
128 132                          let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
129 133                          let wxLpTransfer = ScriptTransfer(i.caller, (am - fee), wxUsdnLP)
130 134                          let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
131 135                          let burnWxLpTci = Burn(wxUsdnLP, am)
132 136                          if ((burnWxLpTci == burnWxLpTci))
133 137                              then [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked]
134 138                              else throw("Strict value is not equal to itself.")
135 139                          }
136 140                      else throw("Strict value is not equal to itself.")
137 141                  }
138 142              else if ((id == usdcUsdnLPTCI))
139 143                  then {
140 144                      let usdcUsdnTCI =                     match assetInfo(usdcUsdnLPTCI) {
141 145                          case q: Asset => 
142 146                              q.quantity
143 147                          case _ => 
144 148                              0
145 149                      }
146 150                      let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
147 151                      let singleUsdcLP = fraction(usdcUsdnTCI, def, usdcUsdnStaked)
148 152                      let usdcLpToWithdraw = fraction(singleUsdcLP, am, def)
149 153                      let fee = fraction(usdcLpToWithdraw, def, feePerc)
150 154                      let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
151 155                      let usdcUsdnTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdnLP)
152 156                      let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcLpToWithdraw))
153 157                      let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
154 158                      if ((burnUsdcUsdnLpTci == burnUsdcUsdnLpTci))
155 159                          then [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked]
156 160                          else throw("Strict value is not equal to itself.")
157 161                      }
158 162                  else if ((id == usdcUsdtLPTCI))
159 163                      then {
160 164                          let usdcUsdtTci =                         match assetInfo(usdcUsdnLPTCI) {
161 165                              case q: Asset => 
162 166                                  q.quantity
163 167                              case _ => 
164 168                                  0
165 169                          }
166 170                          let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
167 171                          let singleUsdcUsdt = fraction(usdcUsdtTci, def, usdcUsdtStaked)
168 172                          let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
169 173                          let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
170 174                          let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
171 175                          let usdcUsdtTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdtLP)
172 176                          let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
173 177                          let burnWxLpTci = Burn(usdcUsdnLPTCI, am)
174 178                          if ((burnWxLpTci == burnWxLpTci))
175 179                              then [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked]
176 180                              else throw("Strict value is not equal to itself.")
177 181                          }
178 182                      else if ((id == puzzleUsdnLPTCI))
179 183                          then {
180 184                              let puzzleUsdnTci =                             match assetInfo(puzzleUsdnLPTCI) {
181 185                                  case q: Asset => 
182 186                                      q.quantity
183 187                                  case _ => 
184 188                                      0
185 189                              }
186 190                              let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
187 191                              let singlePuzzleUsdn = fraction(puzzleUsdnTci, def, puzzleLPStaked)
188 192                              let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
189 193                              let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
190 194                              let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
191 195                              let puzzleUsdnTransfer = ScriptTransfer(i.caller, (am - fee), puzzleUsdnLP)
192 196                              let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
193 197                              let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
194 198                              if ((burnPuzzleTCI == burnPuzzleTCI))
195 199                                  then [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked]
196 200                                  else throw("Strict value is not equal to itself.")
197 201                              }
198 202                          else throw("Invalid asset")
199 203      }
200 204  
201 205  
202 206  
203 207  @Callable(i)
204 208  func depositWxUsdnLP () = {
205 209      let pmt = value(i.payments[0])
206 210      let pmtAmount = pmt.amount
207 211      if ((pmt.assetId != wxUsdnLP))
208 212          then throw("attach WXUSDNLP tokens only")
209 213          else if (isStopped)
210 214              then throw("smart contract is on lock")
211 215              else {
212 216                  let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
213 217                  let totalIssued =                 match assetInfo(wxUsdnLPTCI) {
214 218                      case asset: Asset => 
215 219                          asset.quantity
216 220                      case _ => 
217 221                          throw("Can't find asset")
218 222                  }
219 223                  let one = fraction(totalIssued, 100000000, tkStaked)
220 224                  let toIssue = fraction(pmtAmount, one, 100000000)
221 225                  let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
222 226                  let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
223 227                  if ((LPstake == LPstake))
224 228                      then {
225 229                          let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
226 230                          let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
227 231  [LPIssue, transfer, updateState]
228 232                          }
229 233                      else throw("Strict value is not equal to itself.")
230 234                  }
231 235      }
232 236  
233 237  
234 238  
235 239  @Callable(i)
236 240  func depositUsdtUsdnLP () = {
237 241      let pmt = value(i.payments[0])
238 242      let pmtAmount = pmt.amount
239 243      if ((pmt.assetId != usdtUsdnLP))
240 244          then throw("attach USDTUSDNLP tokens only")
241 245          else if (isStopped)
242 246              then throw("smart contract is on lock")
243 247              else {
244 248                  let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
245 249                  let totalIssued =                 match assetInfo(usdtUsdnLPTCI) {
246 250                      case asset: Asset => 
247 251                          asset.quantity
248 252                      case _ => 
249 253                          throw("Can't find asset")
250 254                  }
251 255                  let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
252 256                  let forOne = fraction(totalIssued, 100000000, tkStaked)
253 257                  let toIssue = fraction(pmtAmount, forOne, 100000000)
254 258                  let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
255 259                  let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
256 260                  if ((LPstake == LPstake))
257 261                      then {
258 262                          let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
259 263                          let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
260 264  [LPIssue, transfer, updateState]
261 265                          }
262 266                      else throw("Strict value is not equal to itself.")
263 267                  }
264 268      }
265 269  
266 270  
267 271  
268 272  @Callable(i)
269 273  func depositUsdcUsdnLP () = {
270 274      let pmt = value(i.payments[0])
271 275      let pmtAmount = pmt.amount
272 276      if ((pmt.assetId != usdcUsdnLP))
273 277          then throw("attach USDCUSDNLP tokens only")
274 278          else if (isStopped)
275 279              then throw("smart contract is on lock")
276 280              else {
277 281                  let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
278 282                  let totalIssued =                 match assetInfo(usdcUsdnLPTCI) {
279 283                      case asset: Asset => 
280 284                          asset.quantity
281 285                      case _ => 
282 286                          throw("Can't find asset")
283 287                  }
284 288                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
285 289                  let forOne = fraction(totalIssued, 100000000, tkStaked)
286 290                  let toIssue = fraction(pmtAmount, forOne, 100000000)
287 291                  let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
288 292                  let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
289 293                  if ((LPstake == LPstake))
290 294                      then {
291 295                          let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
292 296                          let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
293 297  [LPIssue, transfer, updateState]
294 298                          }
295 299                      else throw("Strict value is not equal to itself.")
296 300                  }
297 301      }
298 302  
299 303  
300 304  
301 305  @Callable(i)
302 306  func depositUsdcUsdtLP () = {
303 307      let pmt = value(i.payments[0])
304 308      let pmtAmount = pmt.amount
305 309      if ((pmt.assetId != usdcUsdtLP))
306 310          then throw("attach USDCUSDTLP tokens only")
307 311          else if (isStopped)
308 312              then throw("smart contract is on lock")
309 313              else {
310 314                  let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
311 315                  let totalIssued =                 match assetInfo(usdcUsdtLPTCI) {
312 316                      case asset: Asset => 
313 317                          asset.quantity
314 318                      case _ => 
315 319                          throw("Can't find asset")
316 320                  }
317 321                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
318 322                  let forOne = fraction(totalIssued, 100000000, tkStaked)
319 323                  let toIssue = fraction(pmtAmount, forOne, 100000000)
320 324                  let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
321 325                  let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
322 326                  if ((LPstake == LPstake))
323 327                      then {
324 328                          let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
325 329                          let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
326 330  [LPIssue, transfer, updateState]
327 331                          }
328 332                      else throw("Strict value is not equal to itself.")
329 333                  }
330 334      }
331 335  
332 336  
333 337  
334 338  @Callable(i)
335 339  func depositPuzzleUsdnLP () = {
336 340      let pmt = value(i.payments[0])
337 341      let pmtAmount = pmt.amount
338 342      if ((pmt.assetId != puzzleUsdnLP))
339 343          then throw("attach PUZZLEUDSNLP tokens only")
340 344          else if (isStopped)
341 345              then throw("smart contract is on lock")
342 346              else {
343 347                  let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
344 348                  let totalIssued =                 match assetInfo(puzzleUsdnLPTCI) {
345 349                      case asset: Asset => 
346 350                          asset.quantity
347 351                      case _ => 
348 352                          throw("Can't find asset")
349 353                  }
350 354                  let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
351 355                  let forOne = fraction(totalIssued, 100000000, tkStaked)
352 356                  let toIssue = fraction(pmtAmount, forOne, 100000000)
353 357                  let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
354 358                  let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
355 359                  if ((LPstake == LPstake))
356 360                      then {
357 361                          let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
358 362                          let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
359 363  [LPIssue, transfer, updateState]
360 364                          }
361 365                      else throw("Strict value is not equal to itself.")
362 366                  }
363 367      }
364 368  
365 369  
366 370  
367 371  @Callable(i)
368 372  func compoundWxUsdnLP () = {
369 373      let compound = value(i.payments[0])
370 374      let ca = compound.amount
371 375      let isOracle = checkAddress(i.caller.bytes)
372 376      if ((compound.assetId != wxUsdnLP))
373 377          then throw("attach WXUSDNLP tokens only")
374 378          else if (!(isOracle))
375 379              then throw("You are not authotized to call this function")
376 380              else {
377 381                  let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
378 382                  let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
379 383                  let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
380 384                  if ((stakeC == stakeC))
381 385                      then {
382 386                          let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
383 387                          let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
384 388  [updateState, tc]
385 389                          }
386 390                      else throw("Strict value is not equal to itself.")
387 391                  }
388 392      }
389 393  
390 394  
391 395  
392 396  @Callable(i)
393 397  func compoundUsdtUsdnLP () = {
394 398      let compound = value(i.payments[0])
395 399      let ca = compound.amount
396 400      let isOracle = checkAddress(i.caller.bytes)
397 401      if ((compound.assetId != usdtUsdnLP))
398 402          then throw("attach USDTUSDNLP tokens only")
399 403          else if (!(isOracle))
400 404              then throw("You are not authotized to call this function")
401 405              else {
402 406                  let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
403 407                  let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
404 408                  let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
405 409                  if ((stakeC == stakeC))
406 410                      then {
407 411                          let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
408 412                          let tc = IntegerEntry(keyCompound, (fromCompound + ca))
409 413  [updateState, tc]
410 414                          }
411 415                      else throw("Strict value is not equal to itself.")
412 416                  }
413 417      }
414 418  
415 419  
416 420  
417 421  @Callable(i)
418 422  func compoundUsdcUsdnLP () = {
419 423      let compound = value(i.payments[0])
420 424      let ca = compound.amount
421 425      let isOracle = checkAddress(i.caller.bytes)
422 426      if ((compound.assetId != usdcUsdnLP))
423 427          then throw("attach USDCUSDNLP tokens only")
424 428          else if (!(isOracle))
425 429              then throw("You are not authotized to call this function")
426 430              else {
427 431                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
428 432                  let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
429 433                  let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
430 434                  if ((stakeC == stakeC))
431 435                      then {
432 436                          let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
433 437                          let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
434 438  [updateState, tc]
435 439                          }
436 440                      else throw("Strict value is not equal to itself.")
437 441                  }
438 442      }
439 443  
440 444  
441 445  
442 446  @Callable(i)
443 447  func compoundUsdcUsdtLP () = {
444 448      let compound = value(i.payments[0])
445 449      let ca = compound.amount
446 450      let isOracle = checkAddress(i.caller.bytes)
447 451      if ((compound.assetId != usdcUsdtLP))
448 452          then throw("attach USDCUSDTLP tokens only")
449 453          else if (!(isOracle))
450 454              then throw("You are not authotized to call this function")
451 455              else {
452 456                  let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
453 457                  let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
454 458                  let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
455 459                  if ((stakeC == stakeC))
456 460                      then {
457 461                          let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
458 462                          let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
459 463  [updateState, tc]
460 464                          }
461 465                      else throw("Strict value is not equal to itself.")
462 466                  }
463 467      }
464 468  
465 469  
466 470  
467 471  @Callable(i)
468 472  func compoundPuzzleUsdnLP () = {
469 473      let compound = value(i.payments[0])
470 474      let ca = compound.amount
471 475      let isOracle = checkAddress(i.caller.bytes)
472 476      if ((compound.assetId != puzzleUsdnLP))
473 477          then throw("attach PUZZLEUSDNLP tokens only")
474 478          else if (!(isOracle))
475 479              then throw("You are not authotized to call this function")
476 480              else {
477 481                  let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
478 482                  let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
479 483                  let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
480 484                  if ((stakeC == stakeC))
481 485                      then {
482 486                          let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
483 487                          let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
484 488  [updateState, tc]
485 489                          }
486 490                      else throw("Strict value is not equal to itself.")
487 491                  }
488 492      }
489 493  
490 494  
491 495  
492 496  @Callable(i)
493 497  func sponsorBoost () = {
494 498      let pm = value(i.payments[0])
495 499      let lockPeriod = 100
496 500      if ((pm.assetId != wxId))
497 501          then throw("Error")
498 502          else {
499 503              let sponsored = valueOrElse(getInteger(this, keySponsorship), 0)
500 504              let lock = invoke(Address(base58'3PJL8Hn8LACaSBWLQ3UVhctA5cTQLBFwBAP'), "increaseLock", [lockPeriod], [pm])
501 505              if ((lock == lock))
502 506                  then {
503 507                      let s = IntegerEntry(keySponsorship, (pm.amount + sponsored))
504 508  [s]
505 509                      }
506 510                  else throw("Strict value is not equal to itself.")
507 511              }
508 512      }
509 513  
510 514  
511 515  
512 516  @Callable(i)
513 517  func initWX () = {
514 518      let pm = value(i.payments[0])
515 519      let am = pm.amount
516 520      if ((pm.assetId != wxUsdnLP))
517 521          then throw("Unexpected token")
518 522          else {
519 523              let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
520 524              if ((s == s))
521 525                  then {
522 526                      let upd = IntegerEntry(keyWXUSDN, am)
523 527                      let updK = IntegerEntry(keywxUsdnCompound, 0)
524 528  [upd, updK]
525 529                      }
526 530                  else throw("Strict value is not equal to itself.")
527 531              }
528 532      }
529 533  
530 534  
531 535  @Verifier(tx)
532 536  func verify () = sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
533 537

Old	New		Differences
99	99		let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100	100		let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101	101		let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], nil)
102		-	let fee = fraction(usdnLpToWithdraw, def, feePerc)
103		-	let brn = Burn(usdtUsdnLPTCI, am)
104		-	if ((brn == brn))
	102	+	if ((unstake == unstake))
105	103		then {
106		-	let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
107		-	let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
108		-	let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
	104	+	let fee = fraction(usdnLpToWithdraw, def, feePerc)
	105	+	let brn = Burn(usdtUsdnLPTCI, am)
	106	+	if ((brn == brn))
	107	+	then {
	108	+	let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
	109	+	let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
	110	+	let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
109	111		[usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
	112	+	}
	113	+	else throw("Strict value is not equal to itself.")
110	114		}
111	115		else throw("Strict value is not equal to itself.")
112	116		}

Old	New		Differences
1	1		{-# STDLIB_VERSION 6 #-}
2	2		{-# SCRIPT_TYPE ACCOUNT #-}
3	3		{-# CONTENT_TYPE DAPP #-}
4	4		let usdtUsdnLP = base58'Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS'
5	5
6	6		let usdtUsdnLPTCI = base58'i1snzKxSEZVokh9TWj8hTJQEDBsocnL2hRWsSbsMPK7'
7	7
8	8		let wxUsdnLP = base58'2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib'
9	9
10	10		let wxUsdnLPTCI = base58'DNy6WBfhPE4y82RonGdHhZEunNotEDzmNfrBomWnsyGi'
11	11
12	12		let usdcUsdnLP = base58'EK6N7S38xbtBT3SxAqoGdDLCiX6rojX6G169CnSyuE5'
13	13
14	14		let usdcUsdnLPTCI = base58'HZKFpNfyPG5gt4D6Nfy1zQSg2Ptmqv932GjNTCyBEeKP'
15	15
16	16		let usdcUsdtLP = base58'EPhdEfmQaNcHyvDmRGhnLhgcJtKZ2a4k3ZBmKWtAEWyH'
17	17
18	18		let usdcUsdtLPTCI = base58'BqPYkaiz7Le6fFu1rjZ54anrpT57EpvyugZCUqrsjXj'
19	19
20	20		let puzzleUsdnLP = base58'E8zHu33GfcNyGLypX77gZiUXfvuZQeaYmiEfsy7VYNwP'
21	21
22	22		let puzzleUsdnLPTCI = base58'Dh9QXSSABE5V6aRfu3mCbDAUokbpE7ER7pbZV6cvyg1A'
23	23
24	24		let wxId = base58'Atqv59EYzjFGuitKVnMRk6H8FukjoV3ktPorbEys25on'
25	25
26	26		let keySponsorship = "Sponsorship_in_lock"
27	27
28	28		let isStopped = false
29	29
30	30		let keyStaked = "STAKED_LP"
31	31
32	32		let keyCompound = "From_Compound"
33	33
34	34		let keywxUsdnCompound = "WX_USDN_compound"
35	35
36	36		let keyWXUSDN = "WX_USDN"
37	37
38	38		let keyUsdcUsdnCompound = "USDC_USDN_compound"
39	39
40	40		let keyUSDCUSDN = "USDC_USDN"
41	41
42	42		let keyUsdcUsdtCompound = "USDC_USDT_compound"
43	43
44	44		let keyUSDCUSDT = "USDC_USDT"
45	45
46	46		let keyPuzzleUsdnCompound = "PUZZLE_USDN_compound"
47	47
48	48		let keyPUZZLEUSDN = "PUZZLE_USDN"
49	49
50	50		let def = 100000000
51	51
52	52		let feePerc = 10000000000
53	53
54	54		let tw = base58'3Mv7nXq2V2Dnn9oSkB5feRt6RxtqnPiAXNH'
55	55
56	56		let oracle = base58'3NAVBWBnqieKa3CdN39MAhToyTHShYxX1gB'
57	57
58	58		let stakePool = "3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz"
59	59
60	60		func checkAddress (caller) = if ((caller != oracle))
61	61		then false
62	62		else true
63	63
64	64
65	65		@Callable(i)
66	66		func initUsdtUsdn () = {
67	67		let pm = value(i.payments[0])
68	68		let am = pm.amount
69	69		if ((pm.assetId != usdtUsdnLP))
70	70		then throw("Unexpected token")
71	71		else {
72	72		let s = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pm])
73	73		if ((s == s))
74	74		then {
75	75		let upd = IntegerEntry(keyStaked, am)
76	76		let updK = IntegerEntry(keyCompound, 0)
77	77		[upd, updK]
78	78		}
79	79		else throw("Strict value is not equal to itself.")
80	80		}
81	81		}
82	82
83	83
84	84
85	85		@Callable(i)
86	86		func withdraw () = {
87	87		let payment = value(i.payments[0])
88	88		let am = payment.amount
89	89		let id = payment.assetId
90	90		if ((id == usdtUsdnLPTCI))
91	91		then {
92	92		let TCIAmount = match assetInfo(usdtUsdnLPTCI) {
93	93		case q: Asset =>
94	94		q.quantity
95	95		case _ =>
96	96		0
97	97		}
98	98		let usdnUsdtStaked = valueOrElse(getInteger(this, keyStaked), 0)
99	99		let forSingleTCI = fraction(usdnUsdtStaked, def, TCIAmount)
100	100		let usdnLpToWithdraw = fraction(forSingleTCI, am, def)
101	101		let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["Fm4qczu6Pepz8KUhh3Heb6LeTVfpSMX5vvNgw3x764CS", usdnLpToWithdraw], nil)
102		-	let fee = fraction(usdnLpToWithdraw, def, feePerc)
103		-	let brn = Burn(usdtUsdnLPTCI, am)
104		-	if ((brn == brn))
	102	+	if ((unstake == unstake))
105	103		then {
106		-	let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
107		-	let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
108		-	let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
	104	+	let fee = fraction(usdnLpToWithdraw, def, feePerc)
	105	+	let brn = Burn(usdtUsdnLPTCI, am)
	106	+	if ((brn == brn))
	107	+	then {
	108	+	let updateUsdnLpStaked = IntegerEntry(keyStaked, (usdnUsdtStaked - usdnLpToWithdraw))
	109	+	let usdnLpfeeTransfer = ScriptTransfer(Address(tw), fee, usdtUsdnLP)
	110	+	let transfer = ScriptTransfer(i.caller, (usdnLpToWithdraw - fee), usdtUsdnLP)
109	111		[usdnLpfeeTransfer, transfer, updateUsdnLpStaked]
	112	+	}
	113	+	else throw("Strict value is not equal to itself.")
110	114		}
111	115		else throw("Strict value is not equal to itself.")
112	116		}
113	117		else if ((id == wxUsdnLPTCI))
114	118		then {
115	119		let wxTciAm = match assetInfo(wxUsdnLPTCI) {
116	120		case q: Asset =>
117	121		q.quantity
118	122		case _ =>
119	123		0
120	124		}
121	125		let wxUsdnStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
122	126		let singleWXLP = fraction(wxUsdnStaked, def, wxTciAm)
123	127		let wxLpToWithdraw = fraction(singleWXLP, am, def)
124	128		let fee = fraction(wxLpToWithdraw, def, feePerc)
125	129		let unstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "unstake", ["2sEBVcyDFK2LupCf7MeA4vzHhGK4DC1WjbKGQCLYDqib", wxLpToWithdraw], nil)
126	130		if ((unstake == unstake))
127	131		then {
128	132		let wxLpFeeTransfer = ScriptTransfer(Address(tw), fee, wxUsdnLP)
129	133		let wxLpTransfer = ScriptTransfer(i.caller, (am - fee), wxUsdnLP)
130	134		let updateWxLpStaked = IntegerEntry(keyWXUSDN, (wxUsdnStaked - wxLpToWithdraw))
131	135		let burnWxLpTci = Burn(wxUsdnLP, am)
132	136		if ((burnWxLpTci == burnWxLpTci))
133	137		then [wxLpFeeTransfer, wxLpTransfer, updateWxLpStaked]
134	138		else throw("Strict value is not equal to itself.")
135	139		}
136	140		else throw("Strict value is not equal to itself.")
137	141		}
138	142		else if ((id == usdcUsdnLPTCI))
139	143		then {
140	144		let usdcUsdnTCI = match assetInfo(usdcUsdnLPTCI) {
141	145		case q: Asset =>
142	146		q.quantity
143	147		case _ =>
144	148		0
145	149		}
146	150		let usdcUsdnStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
147	151		let singleUsdcLP = fraction(usdcUsdnTCI, def, usdcUsdnStaked)
148	152		let usdcLpToWithdraw = fraction(singleUsdcLP, am, def)
149	153		let fee = fraction(usdcLpToWithdraw, def, feePerc)
150	154		let usdcUsdnLPFee = ScriptTransfer(Address(tw), fee, usdcUsdnLP)
151	155		let usdcUsdnTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdnLP)
152	156		let updateUsdcUsdnLpStaked = IntegerEntry(keyUSDCUSDN, (usdcUsdnStaked - usdcLpToWithdraw))
153	157		let burnUsdcUsdnLpTci = Burn(usdcUsdnLPTCI, am)
154	158		if ((burnUsdcUsdnLpTci == burnUsdcUsdnLpTci))
155	159		then [usdcUsdnLPFee, usdcUsdnTransfer, updateUsdcUsdnLpStaked]
156	160		else throw("Strict value is not equal to itself.")
157	161		}
158	162		else if ((id == usdcUsdtLPTCI))
159	163		then {
160	164		let usdcUsdtTci = match assetInfo(usdcUsdnLPTCI) {
161	165		case q: Asset =>
162	166		q.quantity
163	167		case _ =>
164	168		0
165	169		}
166	170		let usdcUsdtStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
167	171		let singleUsdcUsdt = fraction(usdcUsdtTci, def, usdcUsdtStaked)
168	172		let usdcUsdtLpToWithdraw = fraction(singleUsdcUsdt, am, def)
169	173		let fee = fraction(usdcUsdtLpToWithdraw, def, feePerc)
170	174		let usdcUsdtLPFee = ScriptTransfer(Address(tw), fee, usdcUsdtLP)
171	175		let usdcUsdtTransfer = ScriptTransfer(i.caller, (am - fee), usdcUsdtLP)
172	176		let updateUsdcUsdtLpStaked = IntegerEntry(keyUSDCUSDT, (usdcUsdtStaked - usdcUsdtLpToWithdraw))
173	177		let burnWxLpTci = Burn(usdcUsdnLPTCI, am)
174	178		if ((burnWxLpTci == burnWxLpTci))
175	179		then [usdcUsdtLPFee, usdcUsdtTransfer, updateUsdcUsdtLpStaked]
176	180		else throw("Strict value is not equal to itself.")
177	181		}
178	182		else if ((id == puzzleUsdnLPTCI))
179	183		then {
180	184		let puzzleUsdnTci = match assetInfo(puzzleUsdnLPTCI) {
181	185		case q: Asset =>
182	186		q.quantity
183	187		case _ =>
184	188		0
185	189		}
186	190		let puzzleLPStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
187	191		let singlePuzzleUsdn = fraction(puzzleUsdnTci, def, puzzleLPStaked)
188	192		let puzzleUsdnWithdraw = fraction(singlePuzzleUsdn, am, def)
189	193		let fee = fraction(puzzleUsdnWithdraw, def, feePerc)
190	194		let puzzleUsdnLPFee = ScriptTransfer(Address(tw), fee, puzzleUsdnLP)
191	195		let puzzleUsdnTransfer = ScriptTransfer(i.caller, (am - fee), puzzleUsdnLP)
192	196		let updatePuzzleUsdnLpStaked = IntegerEntry(keyPUZZLEUSDN, (puzzleLPStaked - puzzleUsdnWithdraw))
193	197		let burnPuzzleTCI = Burn(puzzleUsdnLPTCI, am)
194	198		if ((burnPuzzleTCI == burnPuzzleTCI))
195	199		then [puzzleUsdnLPFee, puzzleUsdnTransfer, updatePuzzleUsdnLpStaked]
196	200		else throw("Strict value is not equal to itself.")
197	201		}
198	202		else throw("Invalid asset")
199	203		}
200	204
201	205
202	206
203	207		@Callable(i)
204	208		func depositWxUsdnLP () = {
205	209		let pmt = value(i.payments[0])
206	210		let pmtAmount = pmt.amount
207	211		if ((pmt.assetId != wxUsdnLP))
208	212		then throw("attach WXUSDNLP tokens only")
209	213		else if (isStopped)
210	214		then throw("smart contract is on lock")
211	215		else {
212	216		let tkStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
213	217		let totalIssued = match assetInfo(wxUsdnLPTCI) {
214	218		case asset: Asset =>
215	219		asset.quantity
216	220		case _ =>
217	221		throw("Can't find asset")
218	222		}
219	223		let one = fraction(totalIssued, 100000000, tkStaked)
220	224		let toIssue = fraction(pmtAmount, one, 100000000)
221	225		let updateState = IntegerEntry(keyWXUSDN, (tkStaked + pmtAmount))
222	226		let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
223	227		if ((LPstake == LPstake))
224	228		then {
225	229		let LPIssue = Reissue(wxUsdnLPTCI, toIssue, true)
226	230		let transfer = ScriptTransfer(i.caller, toIssue, wxUsdnLPTCI)
227	231		[LPIssue, transfer, updateState]
228	232		}
229	233		else throw("Strict value is not equal to itself.")
230	234		}
231	235		}
232	236
233	237
234	238
235	239		@Callable(i)
236	240		func depositUsdtUsdnLP () = {
237	241		let pmt = value(i.payments[0])
238	242		let pmtAmount = pmt.amount
239	243		if ((pmt.assetId != usdtUsdnLP))
240	244		then throw("attach USDTUSDNLP tokens only")
241	245		else if (isStopped)
242	246		then throw("smart contract is on lock")
243	247		else {
244	248		let tkStaked = valueOrElse(getInteger(this, keyStaked), 0)
245	249		let totalIssued = match assetInfo(usdtUsdnLPTCI) {
246	250		case asset: Asset =>
247	251		asset.quantity
248	252		case _ =>
249	253		throw("Can't find asset")
250	254		}
251	255		let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
252	256		let forOne = fraction(totalIssued, 100000000, tkStaked)
253	257		let toIssue = fraction(pmtAmount, forOne, 100000000)
254	258		let updateState = IntegerEntry(keyStaked, (tkStaked + pmtAmount))
255	259		let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
256	260		if ((LPstake == LPstake))
257	261		then {
258	262		let LPIssue = Reissue(usdtUsdnLPTCI, toIssue, true)
259	263		let transfer = ScriptTransfer(i.caller, toIssue, usdtUsdnLPTCI)
260	264		[LPIssue, transfer, updateState]
261	265		}
262	266		else throw("Strict value is not equal to itself.")
263	267		}
264	268		}
265	269
266	270
267	271
268	272		@Callable(i)
269	273		func depositUsdcUsdnLP () = {
270	274		let pmt = value(i.payments[0])
271	275		let pmtAmount = pmt.amount
272	276		if ((pmt.assetId != usdcUsdnLP))
273	277		then throw("attach USDCUSDNLP tokens only")
274	278		else if (isStopped)
275	279		then throw("smart contract is on lock")
276	280		else {
277	281		let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
278	282		let totalIssued = match assetInfo(usdcUsdnLPTCI) {
279	283		case asset: Asset =>
280	284		asset.quantity
281	285		case _ =>
282	286		throw("Can't find asset")
283	287		}
284	288		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
285	289		let forOne = fraction(totalIssued, 100000000, tkStaked)
286	290		let toIssue = fraction(pmtAmount, forOne, 100000000)
287	291		let updateState = IntegerEntry(keyUSDCUSDN, (tkStaked + pmtAmount))
288	292		let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
289	293		if ((LPstake == LPstake))
290	294		then {
291	295		let LPIssue = Reissue(usdcUsdnLPTCI, toIssue, true)
292	296		let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdnLPTCI)
293	297		[LPIssue, transfer, updateState]
294	298		}
295	299		else throw("Strict value is not equal to itself.")
296	300		}
297	301		}
298	302
299	303
300	304
301	305		@Callable(i)
302	306		func depositUsdcUsdtLP () = {
303	307		let pmt = value(i.payments[0])
304	308		let pmtAmount = pmt.amount
305	309		if ((pmt.assetId != usdcUsdtLP))
306	310		then throw("attach USDCUSDTLP tokens only")
307	311		else if (isStopped)
308	312		then throw("smart contract is on lock")
309	313		else {
310	314		let tkStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
311	315		let totalIssued = match assetInfo(usdcUsdtLPTCI) {
312	316		case asset: Asset =>
313	317		asset.quantity
314	318		case _ =>
315	319		throw("Can't find asset")
316	320		}
317	321		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
318	322		let forOne = fraction(totalIssued, 100000000, tkStaked)
319	323		let toIssue = fraction(pmtAmount, forOne, 100000000)
320	324		let updateState = IntegerEntry(keyUSDCUSDT, (tkStaked + pmtAmount))
321	325		let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
322	326		if ((LPstake == LPstake))
323	327		then {
324	328		let LPIssue = Reissue(usdcUsdtLPTCI, toIssue, true)
325	329		let transfer = ScriptTransfer(i.caller, toIssue, usdcUsdtLPTCI)
326	330		[LPIssue, transfer, updateState]
327	331		}
328	332		else throw("Strict value is not equal to itself.")
329	333		}
330	334		}
331	335
332	336
333	337
334	338		@Callable(i)
335	339		func depositPuzzleUsdnLP () = {
336	340		let pmt = value(i.payments[0])
337	341		let pmtAmount = pmt.amount
338	342		if ((pmt.assetId != puzzleUsdnLP))
339	343		then throw("attach PUZZLEUDSNLP tokens only")
340	344		else if (isStopped)
341	345		then throw("smart contract is on lock")
342	346		else {
343	347		let tkStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
344	348		let totalIssued = match assetInfo(puzzleUsdnLPTCI) {
345	349		case asset: Asset =>
346	350		asset.quantity
347	351		case _ =>
348	352		throw("Can't find asset")
349	353		}
350	354		let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
351	355		let forOne = fraction(totalIssued, 100000000, tkStaked)
352	356		let toIssue = fraction(pmtAmount, forOne, 100000000)
353	357		let updateState = IntegerEntry(keyPUZZLEUSDN, (tkStaked + pmtAmount))
354	358		let LPstake = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [pmt])
355	359		if ((LPstake == LPstake))
356	360		then {
357	361		let LPIssue = Reissue(puzzleUsdnLPTCI, toIssue, true)
358	362		let transfer = ScriptTransfer(i.caller, toIssue, puzzleUsdnLPTCI)
359	363		[LPIssue, transfer, updateState]
360	364		}
361	365		else throw("Strict value is not equal to itself.")
362	366		}
363	367		}
364	368
365	369
366	370
367	371		@Callable(i)
368	372		func compoundWxUsdnLP () = {
369	373		let compound = value(i.payments[0])
370	374		let ca = compound.amount
371	375		let isOracle = checkAddress(i.caller.bytes)
372	376		if ((compound.assetId != wxUsdnLP))
373	377		then throw("attach WXUSDNLP tokens only")
374	378		else if (!(isOracle))
375	379		then throw("You are not authotized to call this function")
376	380		else {
377	381		let fromCompound = valueOrElse(getInteger(this, keywxUsdnCompound), 0)
378	382		let totalStaked = valueOrElse(getInteger(this, keyWXUSDN), 0)
379	383		let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
380	384		if ((stakeC == stakeC))
381	385		then {
382	386		let updateState = IntegerEntry(keyWXUSDN, (totalStaked + ca))
383	387		let tc = IntegerEntry(keywxUsdnCompound, (fromCompound + ca))
384	388		[updateState, tc]
385	389		}
386	390		else throw("Strict value is not equal to itself.")
387	391		}
388	392		}
389	393
390	394
391	395
392	396		@Callable(i)
393	397		func compoundUsdtUsdnLP () = {
394	398		let compound = value(i.payments[0])
395	399		let ca = compound.amount
396	400		let isOracle = checkAddress(i.caller.bytes)
397	401		if ((compound.assetId != usdtUsdnLP))
398	402		then throw("attach USDTUSDNLP tokens only")
399	403		else if (!(isOracle))
400	404		then throw("You are not authotized to call this function")
401	405		else {
402	406		let fromCompound = valueOrElse(getInteger(this, keyCompound), 0)
403	407		let totalStaked = valueOrElse(getInteger(this, keyStaked), 0)
404	408		let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
405	409		if ((stakeC == stakeC))
406	410		then {
407	411		let updateState = IntegerEntry(keyStaked, (totalStaked + ca))
408	412		let tc = IntegerEntry(keyCompound, (fromCompound + ca))
409	413		[updateState, tc]
410	414		}
411	415		else throw("Strict value is not equal to itself.")
412	416		}
413	417		}
414	418
415	419
416	420
417	421		@Callable(i)
418	422		func compoundUsdcUsdnLP () = {
419	423		let compound = value(i.payments[0])
420	424		let ca = compound.amount
421	425		let isOracle = checkAddress(i.caller.bytes)
422	426		if ((compound.assetId != usdcUsdnLP))
423	427		then throw("attach USDCUSDNLP tokens only")
424	428		else if (!(isOracle))
425	429		then throw("You are not authotized to call this function")
426	430		else {
427	431		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdnCompound), 0)
428	432		let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDN), 0)
429	433		let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
430	434		if ((stakeC == stakeC))
431	435		then {
432	436		let updateState = IntegerEntry(keyUSDCUSDN, (totalStaked + ca))
433	437		let tc = IntegerEntry(keyUsdcUsdnCompound, (fromCompound + ca))
434	438		[updateState, tc]
435	439		}
436	440		else throw("Strict value is not equal to itself.")
437	441		}
438	442		}
439	443
440	444
441	445
442	446		@Callable(i)
443	447		func compoundUsdcUsdtLP () = {
444	448		let compound = value(i.payments[0])
445	449		let ca = compound.amount
446	450		let isOracle = checkAddress(i.caller.bytes)
447	451		if ((compound.assetId != usdcUsdtLP))
448	452		then throw("attach USDCUSDTLP tokens only")
449	453		else if (!(isOracle))
450	454		then throw("You are not authotized to call this function")
451	455		else {
452	456		let fromCompound = valueOrElse(getInteger(this, keyUsdcUsdtCompound), 0)
453	457		let totalStaked = valueOrElse(getInteger(this, keyUSDCUSDT), 0)
454	458		let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
455	459		if ((stakeC == stakeC))
456	460		then {
457	461		let updateState = IntegerEntry(keyUSDCUSDT, (totalStaked + ca))
458	462		let tc = IntegerEntry(keyUsdcUsdtCompound, (fromCompound + ca))
459	463		[updateState, tc]
460	464		}
461	465		else throw("Strict value is not equal to itself.")
462	466		}
463	467		}
464	468
465	469
466	470
467	471		@Callable(i)
468	472		func compoundPuzzleUsdnLP () = {
469	473		let compound = value(i.payments[0])
470	474		let ca = compound.amount
471	475		let isOracle = checkAddress(i.caller.bytes)
472	476		if ((compound.assetId != puzzleUsdnLP))
473	477		then throw("attach PUZZLEUSDNLP tokens only")
474	478		else if (!(isOracle))
475	479		then throw("You are not authotized to call this function")
476	480		else {
477	481		let fromCompound = valueOrElse(getInteger(this, keyPuzzleUsdnCompound), 0)
478	482		let totalStaked = valueOrElse(getInteger(this, keyPUZZLEUSDN), 0)
479	483		let stakeC = invoke(Address(base58'3Mx3zmXrMcLFCafMuPtXAzR4ZPVeZYb6qLz'), "stake", nil, [compound])
480	484		if ((stakeC == stakeC))
481	485		then {
482	486		let updateState = IntegerEntry(keyPUZZLEUSDN, (totalStaked + ca))
483	487		let tc = IntegerEntry(keyPuzzleUsdnCompound, (fromCompound + ca))
484	488		[updateState, tc]
485	489		}
486	490		else throw("Strict value is not equal to itself.")
487	491		}
488	492		}
489	493
490	494

github/deemru/w8io/3ef1775 
71.26 ms ◑