tx · 4cp5ScUehZXBHKV1vyDdHvnFHvK6tKJCUHmNQ48C3TqH

3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh:  -0.01600000 Waves

2022.10.20 11:14 [2280469] smart account 3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "4cp5ScUehZXBHKV1vyDdHvnFHvK6tKJCUHmNQ48C3TqH",
    "fee": 1600000,
    "feeAssetId": null,
    "timestamp": 1666253779984,
    "version": 1,
    "sender": "3N3g7W8FPoQ7g5EadbAD2GVjrZT5RWpHZZh",
    "senderPublicKey": "Ap7CkWd6fzBU34kGo4GJJzC5q4qWXuLVunzE25PchdGS",
    "proofs": [
        "3ChhFsxo9JENkwjEjQKL1A94NUhYYrFTEhBUoKKatxGt7CrAYCVVSCVsdMHKtCxEhNZwMhszGgMfUxMLxeJioCVC"
    ],
    "script": "base64:AAIFAAAAAAAABswIAhIICgYICBgBCAESABIICgYICAgICAgSAwoBGBIDCgEIEgASABIECgIICCIDU0VQIgx3YXZlc0Fzc2V0SWQiEWludmFsaWRQcmljZUFzc2V0Igh0aHJvd0VyciIDbXNnIgd0aHJvd1BEIhR0aHJvd0NyZWF0ZU5vdENhbGxlZCIRdGhyb3dZb3VOb3RJc3N1ZXIiD3Rocm93UG9vbEV4aXN0cyIVdGhyb3dBc3NldE5vdFZlcmlmaWVkIhZ0aHJvd0ludmFsaWRQcmljZUFzc2V0IhR0aHJvd0ludmFsaWRGZWVBc3NldCIXdGhyb3dJbnZhbGlkQW1vdW50QXNzZXQiEnRocm93SW52YWxpZFN0YXR1cyIfdGhyb3dDYW5BY3RpdmF0ZU9ubHlQZW5kaW5nUG9vbCIddGhyb3dGYWN0b3J5UmV0dXJuZWROb3RTdHJpbmciHHRocm93SW52YWxpZFByaWNlQXNzZXRBbW91bnQiD3Rocm93SW52YWxpZEZlZSITa2V5TWFuYWdlclB1YmxpY0tleSIaa2V5UGVuZGluZ01hbmFnZXJQdWJsaWNLZXkiD2tleUFkbWluUHViS2V5cyIJa2V5U3RhdHVzIg1hbW91bnRBc3NldElkIgxwcmljZUFzc2V0SWQiEmtleUZhY3RvcnlDb250cmFjdCIWa2V5QXNzZXRzU3RvcmVDb250cmFjdCIJa2V5U3VmZml4IgxrZXlMYXN0SW5kZXgiC2luZGV4U3VmZml4Ig1zdGF0dXNQZW5kaW5nIg5zdGF0dXNEZWNsaW5lZCIMc3RhdHVzQWN0aXZlIghzdGF0dXNlcyIPa2V5Q3JlYXRlQ2FsbGVkIg9rZXlDcmVhdGVDYWxsZXIiFGtleUFtb3VudEFzc2V0QW1vdW50IhNrZXlQcmljZUFzc2V0QW1vdW50IglrZXlIZWlnaHQiE2tleUFjdGl2YXRpb25IZWlnaHQiDWtleUZlZUFzc2V0SWQiDGtleUZlZUFtb3VudCIXa2V5QW1vdW50QXNzZXRNaW5BbW91bnQiF2tleVByaWNlQXNzZXRzTWluQW1vdW50Ig5rZXlQcmljZUFzc2V0cyIPZ2V0U3RyaW5nT3JGYWlsIgNrZXkiEnN0cmluZ09wdGlvblRvTGlzdCIMc3RyaW5nT3JVbml0IgckbWF0Y2gwIgFzIg9mYWN0b3J5Q29udHJhY3QiDmlzQ3JlYXRlQ2FsbGVkIhBtdXN0Q3JlYXRlQ2FsbGVkIhZtYW5hZ2VyUHVibGljS2V5T3JVbml0Ih1wZW5kaW5nTWFuYWdlclB1YmxpY0tleU9yVW5pdCIJaXNNYW5hZ2VyIgFpIgJwayILbXVzdE1hbmFnZXIiCW11c3RBZG1pbiIIYWRtaW5QS3MiCmlzVmVyaWZpZWQiB2Fzc2V0SWQiDGdldElkQW5kSW5mbyIHcGF5bWVudCICaWQiBGluZm8iC3ZhbGlkU3RhdHVzIgZzdGF0dXMiEGZhY3RvcnlWMkFkZHJlc3MiEmFzc2V0c1N0b3JlQWRkcmVzcyIUcHJpY2VBc3NldHNNaW5BbW91bnQiFGFtb3VudEFzc2V0TWluQW1vdW50IgpmZWVBc3NldElkIglmZWVBbW91bnQiC2NoZWNrQ2FsbGVyIhJhbW91bnRBc3NldFBheW1lbnQiEXByaWNlQXNzZXRQYXltZW50Ig9mZWVBc3NldFBheW1lbnQiCyR0MDY2NDA2NzEyIg9hbW91bnRBc3NldEluZm8iCyR0MDY3MTU2Nzg0Ig5wcmljZUFzc2V0SW5mbyILJHQwNjc4NzY4NTAiDGZlZUFzc2V0SW5mbyIPcHJpY2VBc3NldHNMaXN0IhptYW5hZ2VyUHJpY2VBc3NldE1pbkFtb3VudCITcHJpY2VBc3NldE1pbkFtb3VudCIQcHJpY2VBc3NldHNJbmRleCIJbGFzdEluZGV4IghjdXJJbmRleCIGY2hlY2tzIgtwb29sQWRkcmVzcyIRYW1vdW50QXNzZXRUaWNrZXIiEHByaWNlQXNzZXRUaWNrZXIiBGxvZ28iEmFjdGl2YXRlTmV3UG9vbEludiIJbHBBc3NldElkIgliZWZvcmVQdXQiA3B1dCIIYWZ0ZXJQdXQiBHVzZXIiDGFkbWluUHViS2V5cyIXcGVuZGluZ01hbmFnZXJQdWJsaWNLZXkiFWNoZWNrTWFuYWdlclB1YmxpY0tleSICcG0iBWhhc1BNIgdjaGVja1BNIgJ0eCIGdmVyaWZ5Ig90YXJnZXRQdWJsaWNLZXkAAAA2AAAAAAFhAgAAAAJfXwAAAAABYgIAAAAFV0FWRVMAAAAAAWMCAAAAE0ludmFsaWQgcHJpY2UgYXNzZXQBAAAAAWQAAAABAAAAAWUJAAACAAAAAQkABLkAAAACCQAETAAAAAICAAAAEHVzZXJfcG9vbHMucmlkZToJAARMAAAAAgUAAAABZQUAAAADbmlsAgAAAAEgAQAAAAFmAAAAAAkBAAAAAWQAAAABAgAAABFQZXJtaXNzaW9uIGRlbmllZAEAAAABZwAAAAAJAQAAAAFkAAAAAQIAAAAkQ3JlYXRlIGlzIG5vdCBjYWxsZWQgZm9yIGFzc2V0cyBwYWlyAQAAAAFoAAAAAAkBAAAAAWQAAAABAgAAAB5Zb3UgYXJlIG5vdCBhbW91bnRBc3NldCBpc3N1ZXIBAAAAAWkAAAAACQEAAAABZAAAAAECAAAAJFBvb2wgd2l0aCBzdWNoIGFzc2V0cyBhbHJlYWR5IGV4aXN0cwEAAAABagAAAAAJAQAAAAFkAAAAAQIAAAAVQXNzZXQgaXMgbm90IHZlcmlmaWVkAQAAAAFrAAAAAAkBAAAAAWQAAAABBQAAAAFjAQAAAAFsAAAAAAkBAAAAAWQAAAABAgAAABFJbnZhbGlkIGZlZSBhc3NldAEAAAABbQAAAAAJAQAAAAFkAAAAAQIAAAAdSW52YWxpZCBhbW91bnQgYXNzZXQgYXR0YWNoZWQBAAAAAW4AAAAACQEAAAABZAAAAAECAAAADkludmFsaWQgc3RhdHVzAQAAAAFvAAAAAAkBAAAAAWQAAAABAgAAACpDYW4gYWN0aXZhdGUgcG9vbCBvbmx5IGluICdwZW5kaW5nJyBzdGF0dXMBAAAAAXAAAAAACQEAAAABZAAAAAECAAAAHUZhY3RvcnlWMiByZXR1cm5lZCBub3Qgc3RyaW5nAQAAAAFxAAAAAAkBAAAAAWQAAAABAgAAABppbnZhbGlkIHByaWNlIGFzc2V0IGFtb3VudAEAAAABcgAAAAAJAQAAAAFkAAAAAQIAAAALaW52YWxpZCBmZWUBAAAAAXMAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAAQbWFuYWdlclB1YmxpY0tleQUAAAADbmlsBQAAAAFhAQAAAAF0AAAAAAkABLkAAAACCQAETAAAAAICAAAAAiVzCQAETAAAAAICAAAAF3BlbmRpbmdNYW5hZ2VyUHVibGljS2V5BQAAAANuaWwFAAAAAWEBAAAAAXUAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAAMYWRtaW5QdWJLZXlzBQAAAANuaWwFAAAAAWEBAAAAAXYAAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAAAZzdGF0dXMJAARMAAAAAgUAAAABdwkABEwAAAACBQAAAAF4BQAAAANuaWwFAAAAAWEBAAAAAXkAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAAPZmFjdG9yeUNvbnRyYWN0BQAAAANuaWwFAAAAAWEBAAAAAXoAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAATYXNzZXRzU3RvcmVDb250cmFjdAUAAAADbmlsBQAAAAFhAQAAAAFBAAAAAgAAAAF3AAAAAXgJAAS5AAAAAgkABEwAAAACAgAAAAYlcyVzJXMJAARMAAAAAgIAAAAGc3VmZml4CQAETAAAAAIFAAAAAXcJAARMAAAAAgUAAAABeAUAAAADbmlsBQAAAAFhAQAAAAFCAAAAAAkABLkAAAACCQAETAAAAAICAAAAAiVzCQAETAAAAAICAAAACWxhc3RJbmRleAUAAAADbmlsBQAAAAFhAAAAAAFDAgAAAAF1AAAAAAFEAgAAAAdwZW5kaW5nAAAAAAFFAgAAAAhkZWNsaW5lZAAAAAABRgIAAAAGYWN0aXZlAAAAAAFHCQAETAAAAAIFAAAAAUQJAARMAAAAAgUAAAABRQkABEwAAAACBQAAAAFGBQAAAANuaWwBAAAAAUgAAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAAAxjcmVhdGVDYWxsZWQJAARMAAAAAgUAAAABdwkABEwAAAACBQAAAAF4BQAAAANuaWwFAAAAAWEBAAAAAUkAAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAAAxjcmVhdGVDYWxsZXIJAARMAAAAAgUAAAABdwkABEwAAAACBQAAAAF4BQAAAANuaWwFAAAAAWEBAAAAAUoAAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAABFhbW91bnRBc3NldEFtb3VudAkABEwAAAACBQAAAAF3CQAETAAAAAIFAAAAAXgFAAAAA25pbAUAAAABYQEAAAABSwAAAAIAAAABdwAAAAF4CQAEuQAAAAIJAARMAAAAAgIAAAAGJXMlcyVzCQAETAAAAAICAAAAEHByaWNlQXNzZXRBbW91bnQJAARMAAAAAgUAAAABdwkABEwAAAACBQAAAAF4BQAAAANuaWwFAAAAAWEBAAAAAUwAAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAAAZoZWlnaHQJAARMAAAAAgUAAAABdwkABEwAAAACBQAAAAF4BQAAAANuaWwFAAAAAWEBAAAAAU0AAAACAAAAAXcAAAABeAkABLkAAAACCQAETAAAAAICAAAABiVzJXMlcwkABEwAAAACAgAAABBhY3RpdmF0aW9uSGVpZ2h0CQAETAAAAAIFAAAAAXcJAARMAAAAAgUAAAABeAUAAAADbmlsBQAAAAFhAQAAAAFOAAAAAAkABLkAAAACCQAETAAAAAICAAAAAiVzCQAETAAAAAICAAAACmZlZUFzc2V0SWQFAAAAA25pbAUAAAABYQEAAAABTwAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAIlcwkABEwAAAACAgAAAAlmZWVBbW91bnQFAAAAA25pbAUAAAABYQEAAAABUAAAAAAJAAS5AAAAAgkABEwAAAACAgAAAAIlcwkABEwAAAACAgAAABRhbW91bnRBc3NldE1pbkFtb3VudAUAAAADbmlsBQAAAAFhAQAAAAFRAAAAAAkABLkAAAACCQAETAAAAAICAAAAAiVzCQAETAAAAAICAAAAFHByaWNlQXNzZXRzTWluQW1vdW50BQAAAANuaWwFAAAAAWEBAAAAAVIAAAAACQAEuQAAAAIJAARMAAAAAgIAAAACJXMJAARMAAAAAgIAAAALcHJpY2VBc3NldHMFAAAAA25pbAUAAAABYQEAAAABUwAAAAEAAAABVAkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAEHQAAAAIFAAAABHRoaXMFAAAAAVQJAAEsAAAAAgUAAAABVAIAAAAPIGlzIG5vdCBkZWZpbmVkAQAAAAFVAAAAAQAAAAFWBAAAAAFXBQAAAAFWAwkAAAEAAAACBQAAAAFXAgAAAAZTdHJpbmcEAAAAAVgFAAAAAVcDCQAAAAAAAAIJAAExAAAAAQUAAAABWAAAAAAAAAAAAAUAAAADbmlsCQAEtQAAAAIFAAAAAVgFAAAAAWEDCQAAAQAAAAIFAAAAAVcCAAAABFVuaXQFAAAAA25pbAkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgAAAAABWQkBAAAAEUBleHRyTmF0aXZlKDEwNjIpAAAAAQkBAAAAAVMAAAABCQEAAAABeQAAAAABAAAAAVoAAAACAAAAAXcAAAABeAkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABCAAAAABCQEAAAABSAAAAAIFAAAAAXcFAAAAAXgHAQAAAAJhYQAAAAIAAAABdwAAAAF4AwkBAAAAAVoAAAACBQAAAAF3BQAAAAF4BgkBAAAAAWcAAAAAAQAAAAJhYgAAAAAEAAAAAVcJAAQiAAAAAQkBAAAAAXMAAAAAAwkAAAEAAAACBQAAAAFXAgAAAAZTdHJpbmcEAAAAAVgFAAAAAVcJAAJZAAAAAQUAAAABWAMJAAABAAAAAgUAAAABVwIAAAAEVW5pdAUAAAAEdW5pdAkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgEAAAACYWMAAAAABAAAAAFXCQAEIgAAAAEJAQAAAAF0AAAAAAMJAAABAAAAAgUAAAABVwIAAAAGU3RyaW5nBAAAAAFYBQAAAAFXCQACWQAAAAEFAAAAAVgDCQAAAQAAAAIFAAAAAVcCAAAABFVuaXQFAAAABHVuaXQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAAAmFkAAAAAQAAAAJhZQQAAAABVwkBAAAAAmFiAAAAAAMJAAABAAAAAgUAAAABVwIAAAAKQnl0ZVZlY3RvcgQAAAACYWYFAAAAAVcJAAAAAAAAAggFAAAAAmFlAAAAD2NhbGxlclB1YmxpY0tleQUAAAACYWYDCQAAAQAAAAIFAAAAAVcCAAAABFVuaXQJAAAAAAAAAggFAAAAAmFlAAAABmNhbGxlcgUAAAAEdGhpcwkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgEAAAACYWcAAAABAAAAAmFlAwkBAAAAAmFkAAAAAQUAAAACYWUGCQEAAAABZgAAAAABAAAAAmFoAAAAAQAAAAJhZQQAAAACYWkJAQAAAAFVAAAAAQkABCIAAAABCQEAAAABdQAAAAADCQEAAAAPY29udGFpbnNFbGVtZW50AAAAAgUAAAACYWkJAAJYAAAAAQgFAAAAAmFlAAAAD2NhbGxlclB1YmxpY0tleQYJAQAAAAJhZwAAAAEFAAAAAmFlAQAAAAJhagAAAAEAAAACYWsJAAAAAAAAAgkBAAAAC3ZhbHVlT3JFbHNlAAAAAgkABBoAAAACCQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABCQEAAAABUwAAAAEJAQAAAAF6AAAAAAkAASwAAAACCQABLAAAAAICAAAACHN0YXR1c188BQAAAAJhawIAAAABPgAAAAAAAAAAAAAAAAAAAAAAAgEAAAACYWwAAAABAAAAAmFtBAAAAAFXCAUAAAACYW0AAAAHYXNzZXRJZAMJAAABAAAAAgUAAAABVwIAAAAKQnl0ZVZlY3RvcgQAAAACYW4FAAAAAVcEAAAAAmFvCQEAAAAFdmFsdWUAAAABCQAD7AAAAAEFAAAAAmFuCQAFFAAAAAIJAAJYAAAAAQUAAAACYW4FAAAAAmFvAwkAAAEAAAACBQAAAAFXAgAAAARVbml0CQAFFAAAAAIFAAAAAWIFAAAABHVuaXQJAAACAAAAAQIAAAALTWF0Y2ggZXJyb3IBAAAAAmFwAAAAAQAAAAJhcQkBAAAAD2NvbnRhaW5zRWxlbWVudAAAAAIFAAAAAUcFAAAAAmFxAAAACAAAAAJhZQEAAAALY29uc3RydWN0b3IAAAAGAAAAAmFyAAAAAmFzAAAAAmF0AAAAAmF1AAAAAmF2AAAAAmF3BAAAAAJheAkBAAAAAmFnAAAAAQUAAAACYWUDCQAAAAAAAAIFAAAAAmF4BQAAAAJheAkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAABeQAAAAAFAAAAAmFyCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAF6AAAAAAUAAAACYXMJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAAVEAAAAACQAEuQAAAAIFAAAAAmF0BQAAAAFhCQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAABUAAAAAAFAAAAAmF1CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAFOAAAAAAUAAAACYXYJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAFPAAAAAAUAAAACYXcFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAACYWUBAAAABmNyZWF0ZQAAAAAEAAAAAmF5CQEAAAAFdmFsdWUAAAABCQABkQAAAAIIBQAAAAJhZQAAAAhwYXltZW50cwAAAAAAAAAAAAQAAAACYXoJAQAAAAV2YWx1ZQAAAAEJAAGRAAAAAggFAAAAAmFlAAAACHBheW1lbnRzAAAAAAAAAAABBAAAAAJhQQkBAAAABXZhbHVlAAAAAQkAAZEAAAACCAUAAAACYWUAAAAIcGF5bWVudHMAAAAAAAAAAAIEAAAAAmFCCQEAAAACYWwAAAABBQAAAAJheQQAAAABdwgFAAAAAmFCAAAAAl8xBAAAAAJhQwgFAAAAAmFCAAAAAl8yBAAAAAJhRAkBAAAAAmFsAAAAAQUAAAACYXoEAAAAAXgIBQAAAAJhRAAAAAJfMQQAAAACYUUIBQAAAAJhRAAAAAJfMgQAAAACYUYJAQAAAAJhbAAAAAEFAAAAAmFBBAAAAAJhdggFAAAAAmFGAAAAAl8xBAAAAAJhRwgFAAAAAmFGAAAAAl8yBAAAAAJhSAkBAAAAAVUAAAABCQAEHQAAAAIFAAAAAVkJAQAAAAFSAAAAAAQAAAACYUkAAAAAAAAAAAEEAAAAAmFKAwkBAAAAAmFkAAAAAQUAAAACYWUFAAAAAmFJBAAAAAJhSwkBAAAAE3ZhbHVlT3JFcnJvck1lc3NhZ2UAAAACCQAETwAAAAIFAAAAAmFIBQAAAAF4BQAAAAFjCQEAAAAFdmFsdWUAAAABCQAEtgAAAAEJAAGRAAAAAgkBAAAAAVUAAAABCQAEIgAAAAEJAQAAAAFRAAAAAAUAAAACYUsEAAAAAmFMCQEAAAALdmFsdWVPckVsc2UAAAACCQAEHwAAAAEJAQAAAAFCAAAAAAAAAAAAAAAAAAQAAAACYU0JAABkAAAAAgUAAAACYUwAAAAAAAAAAAEEAAAAAmFOCQAETAAAAAIDCQEAAAABIQAAAAEJAQAAAAFaAAAAAgUAAAABdwUAAAABeAYJAQAAAAFpAAAAAAkABEwAAAACAwMJAQAAAAJhZAAAAAEFAAAAAmFlBgkBAAAAAmFqAAAAAQUAAAABdwYJAQAAAAFqAAAAAAkABEwAAAACAwkAAAAAAAACCQAEIgAAAAEJAQAAAAFOAAAAAAUAAAACYXYGCQEAAAABbAAAAAAJAARMAAAAAgMDCQEAAAACYWQAAAABBQAAAAJhZQYJAABnAAAAAggFAAAAAmF5AAAABmFtb3VudAkBAAAAEUBleHRyTmF0aXZlKDEwNTUpAAAAAQkBAAAAAVAAAAAABgkBAAAAAW0AAAAACQAETAAAAAIDAwkBAAAAAmFkAAAAAQUAAAACYWUGCQAAZwAAAAIIBQAAAAJhegAAAAZhbW91bnQFAAAAAmFKBgkBAAAAAXEAAAAACQAETAAAAAIDCQAAAAAAAAIIBQAAAAJhQQAAAAZhbW91bnQJAAQfAAAAAQkBAAAAAU8AAAAABgkBAAAAAXIAAAAABQAAAANuaWwDCQAAAAAAAAIFAAAAAmFOBQAAAAJhTgkABEwAAAACCQEAAAAMQm9vbGVhbkVudHJ5AAAAAgkBAAAAAUgAAAACBQAAAAF3BQAAAAF4BgkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAABSQAAAAIFAAAAAXcFAAAAAXgJAAQlAAAAAQgFAAAAAmFlAAAABmNhbGxlcgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAAUIAAAAABQAAAAJhTQkABEwAAAACCQEAAAALU3RyaW5nRW50cnkAAAACCQEAAAABQQAAAAIFAAAAAXcFAAAAAXgJAAEsAAAAAgkAAaQAAAABBQAAAAJhTQUAAAABQwkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAAUwAAAACBQAAAAF3BQAAAAF4BQAAAAZoZWlnaHQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAAXYAAAACBQAAAAF3BQAAAAF4BQAAAAFECQAETAAAAAIJAQAAAAxJbnRlZ2VyRW50cnkAAAACCQEAAAABSgAAAAIFAAAAAXcFAAAAAXgIBQAAAAJheQAAAAZhbW91bnQJAARMAAAAAgkBAAAADEludGVnZXJFbnRyeQAAAAIJAQAAAAFLAAAAAgUAAAABdwUAAAABeAgFAAAAAmF6AAAABmFtb3VudAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAJhZQEAAAAIYWN0aXZhdGUAAAAGAAAAAmFPAAAAAXcAAAACYVAAAAABeAAAAAJhUQAAAAJhUgQAAAACYU4JAARMAAAAAgkBAAAAAmFoAAAAAQUAAAACYWUJAARMAAAAAgMJAQAAAAFaAAAAAgUAAAABdwUAAAABeAYJAQAAAAFnAAAAAAkABEwAAAACAwkAAAAAAAACCQEAAAAFdmFsdWUAAAABCQAEIgAAAAEJAQAAAAF2AAAAAgUAAAABdwUAAAABeAUAAAABRAYJAQAAAAFvAAAAAAUAAAADbmlsAwkAAAAAAAACBQAAAAJhTgUAAAACYU4EAAAAAmFTCQAD/AAAAAQFAAAAAVkCAAAAD2FjdGl2YXRlTmV3UG9vbAkABEwAAAACBQAAAAJhTwkABEwAAAACBQAAAAF3CQAETAAAAAIFAAAAAXgJAARMAAAAAgkAASwAAAACCQABLAAAAAIFAAAAAmFQBQAAAAJhUQIAAAACTFAJAARMAAAAAgkAASwAAAACCQABLAAAAAIJAAEsAAAAAgUAAAACYVACAAAAAS8FAAAAAmFRAgAAAB4gcG9vbCBsaXF1aWRpdHkgcHJvdmlkZXIgdG9rZW4JAARMAAAAAgAAAAAAAAAAAAkABEwAAAACAgAAAAdWTFRQT09MCQAETAAAAAIFAAAAAmFSBQAAAANuaWwFAAAAA25pbAMJAAAAAAAAAgUAAAACYVMFAAAAAmFTBAAAAAJhVAQAAAABVwUAAAACYVMDCQAAAQAAAAIFAAAAAVcCAAAABlN0cmluZwQAAAACYW4FAAAAAVcFAAAAAmFuCQEAAAABcAAAAAADCQAAAAAAAAIFAAAAAmFUBQAAAAJhVAQAAAACYVUJAAPwAAAAAgUAAAAEdGhpcwkAAlkAAAABBQAAAAJhVAMJAAAAAAAAAgUAAAACYVUFAAAAAmFVBAAAAAJhVgkAA/wAAAAECQEAAAARQGV4dHJOYXRpdmUoMTA2MikAAAABBQAAAAJhTwIAAAADcHV0CQAETAAAAAIAAAAAAAAAAAAJAARMAAAAAgcFAAAAA25pbAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgkAAlkAAAABBQAAAAF3CQEAAAAFdmFsdWUAAAABCQAEHwAAAAEJAQAAAAFKAAAAAgUAAAABdwUAAAABeAkABEwAAAACCQEAAAAPQXR0YWNoZWRQYXltZW50AAAAAgMJAAAAAAAAAgUAAAABeAIAAAAFV0FWRVMFAAAABHVuaXQJAAJZAAAAAQUAAAABeAkBAAAABXZhbHVlAAAAAQkABB8AAAABCQEAAAABSwAAAAIFAAAAAXcFAAAAAXgFAAAAA25pbAMJAAAAAAAAAgUAAAACYVYFAAAAAmFWBAAAAAJhVwkAA/AAAAACBQAAAAR0aGlzCQACWQAAAAEFAAAAAmFUAwkAAAAAAAACBQAAAAJhVwUAAAACYVcEAAAAAmFYCQEAAAAFdmFsdWUAAAABCQAEJgAAAAEJAQAAAAV2YWx1ZQAAAAEJAAQiAAAAAQkBAAAAAUkAAAACBQAAAAF3BQAAAAF4CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAF2AAAAAgUAAAABdwUAAAABeAUAAAABRgkABEwAAAACCQEAAAAMSW50ZWdlckVudHJ5AAAAAgkBAAAAAU0AAAACBQAAAAF3BQAAAAF4BQAAAAZoZWlnaHQJAARMAAAAAgkBAAAADlNjcmlwdFRyYW5zZmVyAAAAAwUAAAACYVgJAABlAAAAAgUAAAACYVcFAAAAAmFVCQACWQAAAAEFAAAAAmFUBQAAAANuaWwJAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAACYWUBAAAACXNldEFkbWlucwAAAAEAAAACYVkEAAAAAmF4CQEAAAACYWcAAAABBQAAAAJhZQMJAAAAAAAAAgUAAAACYXgFAAAAAmF4CQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAF1AAAAAAkABLkAAAACBQAAAAJhWQUAAAABYQUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgAAAAJhZQEAAAAKc2V0TWFuYWdlcgAAAAEAAAACYVoEAAAAAmF4CQEAAAACYWcAAAABBQAAAAJhZQMJAAAAAAAAAgUAAAACYXgFAAAAAmF4BAAAAAJiYQkAAlkAAAABBQAAAAJhWgMJAAAAAAAAAgUAAAACYmEFAAAAAmJhCQAETAAAAAIJAQAAAAtTdHJpbmdFbnRyeQAAAAIJAQAAAAF0AAAAAAUAAAACYVoFAAAAA25pbAkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4JAAACAAAAAQIAAAAkU3RyaWN0IHZhbHVlIGlzIG5vdCBlcXVhbCB0byBpdHNlbGYuAAAAAmFlAQAAAA5jb25maXJtTWFuYWdlcgAAAAAEAAAAAmJiCQEAAAACYWMAAAAABAAAAAJiYwMJAQAAAAlpc0RlZmluZWQAAAABBQAAAAJiYgYJAAACAAAAAQIAAAASTm8gcGVuZGluZyBtYW5hZ2VyAwkAAAAAAAACBQAAAAJiYwUAAAACYmMEAAAAAmJkAwkAAAAAAAACCAUAAAACYWUAAAAPY2FsbGVyUHVibGljS2V5CQEAAAAFdmFsdWUAAAABBQAAAAJiYgYJAAACAAAAAQIAAAAbWW91IGFyZSBub3QgcGVuZGluZyBtYW5hZ2VyAwkAAAAAAAACBQAAAAJiZAUAAAACYmQJAARMAAAAAgkBAAAAC1N0cmluZ0VudHJ5AAAAAgkBAAAAAXMAAAAACQACWAAAAAEJAQAAAAV2YWx1ZQAAAAEFAAAAAmJiCQAETAAAAAIJAQAAAAtEZWxldGVFbnRyeQAAAAEJAQAAAAF0AAAAAAUAAAADbmlsCQAAAgAAAAECAAAAJFN0cmljdCB2YWx1ZSBpcyBub3QgZXF1YWwgdG8gaXRzZWxmLgkAAAIAAAABAgAAACRTdHJpY3QgdmFsdWUgaXMgbm90IGVxdWFsIHRvIGl0c2VsZi4AAAACYWUBAAAAE3ByaWNlQXNzZXRzUkVBRE9OTFkAAAAACQAFFAAAAAIFAAAAA25pbAkBAAAAAVUAAAABCQAEIgAAAAEJAQAAAAFSAAAAAAAAAAJhZQEAAAAOc3RhdHVzUkVBRE9OTFkAAAACAAAAAXcAAAABeAQAAAACYXEEAAAAAVcJAAQiAAAAAQkBAAAAAXYAAAACBQAAAAF3BQAAAAF4AwkAAAEAAAACBQAAAAFXAgAAAAZTdHJpbmcEAAAAAVgFAAAAAVcFAAAAAVgFAAAABHVuaXQJAAUUAAAAAgUAAAADbmlsBQAAAAJhcQAAAAEAAAACYmUBAAAAAmJmAAAAAAQAAAACYmcEAAAAAVcJAQAAAAJhYgAAAAADCQAAAQAAAAIFAAAAAVcCAAAACkJ5dGVWZWN0b3IEAAAAAmFmBQAAAAFXBQAAAAJhZgMJAAABAAAAAgUAAAABVwIAAAAEVW5pdAgFAAAAAmJlAAAAD3NlbmRlclB1YmxpY0tleQkAAAIAAAABAgAAAAtNYXRjaCBlcnJvcgkAAfQAAAADCAUAAAACYmUAAAAJYm9keUJ5dGVzCQABkQAAAAIIBQAAAAJiZQAAAAZwcm9vZnMAAAAAAAAAAAAFAAAAAmJnLok93A==",
    "chainId": 84,
    "height": 2280469,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: FUA7PhACYC7M5uqTsFWxKN1bzPZ3hNEjcn1342abDsSV
Next: FSYWcXjXHxVUJ1d4mhRfPzGRVajwwpqPCCzFVdBmfX1Y

Full: 
Old
New
Differences
1
1
 
{-# STDLIB_VERSION 5 #-}
2
2
 
{-# SCRIPT_TYPE ACCOUNT #-}
3
3
 
{-# CONTENT_TYPE DAPP #-}
4
4
 
let SEP = "__"
5
5
 
6
6
 
let wavesAssetId = "WAVES"
7
7
 
8
8
 
let invalidPriceAsset = "Invalid price asset"
9
9
 
10
10
 
func throwErr (msg) = throw(makeString(["user_pools.ride:", msg], " "))
11
11
 
12
12
 
13
13
 
func throwPD () = throwErr("Permission denied")
14
14
 
15
15
 
16
16
 
func throwCreateNotCalled () = throwErr("Create is not called for assets pair")
17
17
 
18
18
 
19
19
 
func throwYouNotIssuer () = throwErr("You are not amountAsset issuer")
20
20
 
21
21
 
22
22
 
func throwPoolExists () = throwErr("Pool with such assets already exists")
23
23
 
24
24
 
25
25
 
func throwAssetNotVerified () = throwErr("Asset is not verified")
26
26
 
27
27
 
28
28
 
func throwInvalidPriceAsset () = throwErr(invalidPriceAsset)
29
29
 
30
30
 
31
31
 
func throwInvalidFeeAsset () = throwErr("Invalid fee asset")
32
32
 
33
33
 
34
34
 
func throwInvalidAmountAsset () = throwErr("Invalid amount asset attached")
35
35
 
36
36
 
37
37
 
func throwInvalidStatus () = throwErr("Invalid status")
38
38
 
39
39
 
40
40
 
func throwCanActivateOnlyPendingPool () = throwErr("Can activate pool only in 'pending' status")
41
41
 
42
42
 
43
43
 
func throwFactoryReturnedNotString () = throwErr("FactoryV2 returned not string")
44
44
 
45
45
 
46
46
 
func throwInvalidPriceAssetAmount () = throwErr("invalid price asset amount")
47
47
 
48
48
 
49
49
 
func throwInvalidFee () = throwErr("invalid fee")
50
50
 
51
51
 
52
52
 
func keyManagerPublicKey () = makeString(["%s", "managerPublicKey"], SEP)
53
53
 
54
54
 
55
55
 
func keyPendingManagerPublicKey () = makeString(["%s", "pendingManagerPublicKey"], SEP)
56
56
 
57
57
 
58
58
 
func keyAdminPubKeys () = makeString(["%s", "adminPubKeys"], SEP)
59
59
 
60
60
 
61
61
 
func keyStatus (amountAssetId,priceAssetId) = makeString(["%s%s%s", "status", amountAssetId, priceAssetId], SEP)
62
62
 
63
63
 
64
64
 
func keyFactoryContract () = makeString(["%s", "factoryContract"], SEP)
65
65
 
66
66
 
67
67
 
func keyAssetsStoreContract () = makeString(["%s", "assetsStoreContract"], SEP)
68
68
 
69
69
 
70
70
 
func keySuffix (amountAssetId,priceAssetId) = makeString(["%s%s%s", "suffix", amountAssetId, priceAssetId], SEP)
71
71
 
72
72
 
73
73
 
func keyLastIndex () = makeString(["%s", "lastIndex"], SEP)
74
74
 
75
75
 
76
76
 
let indexSuffix = "u"
77
77
 
78
78
 
let statusPending = "pending"
79
79
 
80
80
 
let statusDeclined = "declined"
81
81
 
82
82
 
let statusActive = "active"
83
83
 
84
84
 
let statuses = [statusPending, statusDeclined, statusActive]
85
85
 
86
86
 
func keyCreateCalled (amountAssetId,priceAssetId) = makeString(["%s%s%s", "createCalled", amountAssetId, priceAssetId], SEP)
87
87
 
88
88
 
89
89
 
func keyCreateCaller (amountAssetId,priceAssetId) = makeString(["%s%s%s", "createCaller", amountAssetId, priceAssetId], SEP)
90
90
 
91
91
 
92
92
 
func keyAmountAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "amountAssetAmount", amountAssetId, priceAssetId], SEP)
93
93
 
94
94
 
95
95
 
func keyPriceAssetAmount (amountAssetId,priceAssetId) = makeString(["%s%s%s", "priceAssetAmount", amountAssetId, priceAssetId], SEP)
96
96
 
97
97
 
98
98
 
func keyHeight (amountAssetId,priceAssetId) = makeString(["%s%s%s", "height", amountAssetId, priceAssetId], SEP)
99
99
 
100
100
 
101
101
 
func keyActivationHeight (amountAssetId,priceAssetId) = makeString(["%s%s%s", "activationHeight", amountAssetId, priceAssetId], SEP)
102
102
 
103
103
 
104
104
 
func keyFeeAssetId () = makeString(["%s", "feeAssetId"], SEP)
105
105
 
106
106
 
107
107
 
func keyFeeAmount () = makeString(["%s", "feeAmount"], SEP)
108
108
 
109
109
 
110
110
 
func keyAmountAssetMinAmount () = makeString(["%s", "amountAssetMinAmount"], SEP)
111
111
 
112
112
 
113
113
 
func keyPriceAssetsMinAmount () = makeString(["%s", "priceAssetsMinAmount"], SEP)
114
114
 
115
115
 
116
116
 
func keyPriceAssets () = makeString(["%s", "priceAssets"], SEP)
117
117
 
118
118
 
119
119
 
func getStringOrFail (key) = valueOrErrorMessage(getString(this, key), (key + " is not defined"))
120
120
 
121
121
 
122
122
 
func stringOptionToList (stringOrUnit) = match stringOrUnit {
123
123
 
    case s: String => 
124
124
 
        if ((size(s) == 0))
125
125
 
            then nil
126
126
 
            else split(s, SEP)
127
127
 
    case _: Unit => 
128
128
 
        nil
129
129
 
    case _ => 
130
130
 
        throw("Match error")
131
131
 
}
132
132
 
133
133
 
134
134
 
let factoryContract = addressFromStringValue(getStringOrFail(keyFactoryContract()))
135
135
 
136
136
 
func isCreateCalled (amountAssetId,priceAssetId) = valueOrElse(getBoolean(keyCreateCalled(amountAssetId, priceAssetId)), false)
137
137
 
138
138
 
139
139
 
func mustCreateCalled (amountAssetId,priceAssetId) = if (isCreateCalled(amountAssetId, priceAssetId))
140
140
 
    then true
141
141
 
    else throwCreateNotCalled()
142
142
 
143
143
 
144
144
 
func managerPublicKeyOrUnit () = match getString(keyManagerPublicKey()) {
145
145
 
    case s: String => 
146
146
 
        fromBase58String(s)
147
147
 
    case _: Unit => 
148
148
 
        unit
149
149
 
    case _ => 
150
150
 
        throw("Match error")
151
151
 
}
152
152
 
153
153
 
154
154
 
func pendingManagerPublicKeyOrUnit () = match getString(keyPendingManagerPublicKey()) {
155
155
 
    case s: String => 
156
156
 
        fromBase58String(s)
157
157
 
    case _: Unit => 
158
158
 
        unit
159
159
 
    case _ => 
160
160
 
        throw("Match error")
161
161
 
}
162
162
 
163
163
 
164
164
 
func isManager (i) = match managerPublicKeyOrUnit() {
165
165
 
    case pk: ByteVector => 
166
166
 
        (i.callerPublicKey == pk)
167
167
 
    case _: Unit => 
168
168
 
        (i.caller == this)
169
169
 
    case _ => 
170
170
 
        throw("Match error")
171
171
 
}
172
172
 
173
173
 
174
174
 
func mustManager (i) = if (isManager(i))
175
175
 
    then true
176
176
 
    else throwPD()
177
177
 
178
178
 
179
179
 
func mustAdmin (i) = {
180
180
 
    let adminPKs = stringOptionToList(getString(keyAdminPubKeys()))
181
181
 
    if (containsElement(adminPKs, toBase58String(i.callerPublicKey)))
182
182
 
        then true
183
183
 
        else mustManager(i)
184
184
 
    }
185
185
 
186
186
 
187
187
 
func isVerified (assetId) = (valueOrElse(getInteger(addressFromStringValue(getStringOrFail(keyAssetsStoreContract())), (("status_<" + assetId) + ">")), 0) == 2)
188
188
 
189
189
 
190
190
 
func getIdAndInfo (payment) = match payment.assetId {
191
191
 
    case id: ByteVector => 
192
192
 
        let info = value(assetInfo(id))
193
193
 
        $Tuple2(toBase58String(id), info)
194
194
 
    case _: Unit => 
195
195
 
        $Tuple2(wavesAssetId, unit)
196
196
 
    case _ => 
197
197
 
        throw("Match error")
198
198
 
}
199
199
 
200
200
 
201
201
 
func validStatus (status) = containsElement(statuses, status)
202
202
 
203
203
 
204
204
 
@Callable(i)
205
205
 
func constructor (factoryV2Address,assetsStoreAddress,priceAssetsMinAmount,amountAssetMinAmount,feeAssetId,feeAmount) = {
206
206
 
    let checkCaller = mustManager(i)
207
207
 
    if ((checkCaller == checkCaller))
208
208
 
        then [StringEntry(keyFactoryContract(), factoryV2Address), StringEntry(keyAssetsStoreContract(), assetsStoreAddress), StringEntry(keyPriceAssetsMinAmount(), makeString(priceAssetsMinAmount, SEP)), IntegerEntry(keyAmountAssetMinAmount(), amountAssetMinAmount), StringEntry(keyFeeAssetId(), feeAssetId), IntegerEntry(keyFeeAmount(), feeAmount)]
209
209
 
        else throw("Strict value is not equal to itself.")
210
210
 
    }
211
211
 
212
212
 
213
213
 
214
214
 
@Callable(i)
215
215
 
func create () = {
216
216
 
    let amountAssetPayment = value(i.payments[0])
217
217
 
    let priceAssetPayment = value(i.payments[1])
218
218
 
    let feeAssetPayment = value(i.payments[2])
219
219
 
    let $t066406712 = getIdAndInfo(amountAssetPayment)
220
220
 
    let amountAssetId = $t066406712._1
221
221
 
    let amountAssetInfo = $t066406712._2
222
222
 
    let $t067156784 = getIdAndInfo(priceAssetPayment)
223
223
 
    let priceAssetId = $t067156784._1
224
224
 
    let priceAssetInfo = $t067156784._2
225
225
 
    let $t067876850 = getIdAndInfo(feeAssetPayment)
226
226
 
    let feeAssetId = $t067876850._1
227
227
 
    let feeAssetInfo = $t067876850._2
228
228
 
    let priceAssetsList = stringOptionToList(getString(factoryContract, keyPriceAssets()))
229
229
 
    let managerPriceAssetMinAmount = 1
230
230
 
    let priceAssetMinAmount = if (isManager(i))
231
231
 
        then managerPriceAssetMinAmount
232
232
 
        else {
233
233
 
            let priceAssetsIndex = valueOrErrorMessage(indexOf(priceAssetsList, priceAssetId), invalidPriceAsset)
234
234
 
            value(parseInt(stringOptionToList(getString(keyPriceAssetsMinAmount()))[priceAssetsIndex]))
235
235
 
            }
236
236
 
    let lastIndex = valueOrElse(getInteger(keyLastIndex()), 0)
237
237
 
    let curIndex = (lastIndex + 1)
238
238
 
    let checks = [if (!(isCreateCalled(amountAssetId, priceAssetId)))
239
239
 
        then true
240
240
 
        else throwPoolExists(), if (if (isManager(i))
241
241
 
        then true
242
242
 
        else isVerified(amountAssetId))
243
243
 
        then true
244
244
 
        else throwAssetNotVerified(), if ((getString(keyFeeAssetId()) == feeAssetId))
245
245
 
        then true
246
246
 
        else throwInvalidFeeAsset(), if (if (isManager(i))
247
247
 
        then true
248
248
 
        else (amountAssetPayment.amount >= getIntegerValue(keyAmountAssetMinAmount())))
249
249
 
        then true
250
250
 
        else throwInvalidAmountAsset(), if (if (isManager(i))
251
251
 
        then true
252
252
 
        else (priceAssetPayment.amount >= priceAssetMinAmount))
253
253
 
        then true
254
254
 
        else throwInvalidPriceAssetAmount(), if ((feeAssetPayment.amount == getInteger(keyFeeAmount())))
255
255
 
        then true
256
256
 
        else throwInvalidFee()]
257
257
 
    if ((checks == checks))
258
258
 
        then [BooleanEntry(keyCreateCalled(amountAssetId, priceAssetId), true), StringEntry(keyCreateCaller(amountAssetId, priceAssetId), toString(i.caller)), IntegerEntry(keyLastIndex(), curIndex), StringEntry(keySuffix(amountAssetId, priceAssetId), (toString(curIndex) + indexSuffix)), IntegerEntry(keyHeight(amountAssetId, priceAssetId), height), StringEntry(keyStatus(amountAssetId, priceAssetId), statusPending), IntegerEntry(keyAmountAssetAmount(amountAssetId, priceAssetId), amountAssetPayment.amount), IntegerEntry(keyPriceAssetAmount(amountAssetId, priceAssetId), priceAssetPayment.amount)]
259
259
 
        else throw("Strict value is not equal to itself.")
260
260
 
    }
261
261
 
262
262
 
263
263
 
264
264
 
@Callable(i)
265
265
 
func activate (poolAddress,amountAssetId,amountAssetTicker,priceAssetId,priceAssetTicker,logo) = {
266
266
 
    let checks = [mustAdmin(i), if (isCreateCalled(amountAssetId, priceAssetId))
267
267
 
        then true
268
268
 
        else throwCreateNotCalled(), if ((value(getString(keyStatus(amountAssetId, priceAssetId))) == statusPending))
269
269
 
        then true
270
270
 
        else throwCanActivateOnlyPendingPool()]
271
271
 
    if ((checks == checks))
272
272
 
        then {
273
273
 
            let activateNewPoolInv = invoke(factoryContract, "activateNewPool", [poolAddress, amountAssetId, priceAssetId, ((amountAssetTicker + priceAssetTicker) + "LP"), (((amountAssetTicker + "/") + priceAssetTicker) + " pool liquidity provider token"), 0, "VLTPOOL", logo], nil)
274
274
 
            if ((activateNewPoolInv == activateNewPoolInv))
275
275
 
                then {
276
276
 
                    let lpAssetId =                     match activateNewPoolInv {
277
277
 
                        case id: String => 
278
278
 
                            id
279
279
 
                        case _ => 
280
280
 
                            throwFactoryReturnedNotString()
281
281
 
                    }
282
282
 
                    if ((lpAssetId == lpAssetId))
283
283
 
                        then {
284
284
 
                            let beforePut = assetBalance(this, fromBase58String(lpAssetId))
285
285
 
                            if ((beforePut == beforePut))
286
286
 
                                then {
287
287
 
                                    let put = invoke(addressFromStringValue(poolAddress), "put", [0, false], [AttachedPayment(fromBase58String(amountAssetId), value(getInteger(keyAmountAssetAmount(amountAssetId, priceAssetId)))), AttachedPayment(if ((priceAssetId == "WAVES"))
288
288
 
                                        then unit
289
289
 
                                        else fromBase58String(priceAssetId), value(getInteger(keyPriceAssetAmount(amountAssetId, priceAssetId))))])
290
290
 
                                    if ((put == put))
291
291
 
                                        then {
292
292
 
                                            let afterPut = assetBalance(this, fromBase58String(lpAssetId))
293
293
 
                                            if ((afterPut == afterPut))
294
294
 
                                                then {
295
295
 
                                                    let user = value(addressFromString(value(getString(keyCreateCaller(amountAssetId, priceAssetId)))))
296
296
 
[StringEntry(keyStatus(amountAssetId, priceAssetId), statusActive), IntegerEntry(keyActivationHeight(amountAssetId, priceAssetId), height), ScriptTransfer(user, (afterPut - beforePut), fromBase58String(lpAssetId))]
297
297
 
                                                    }
298
298
 
                                                else throw("Strict value is not equal to itself.")
299
299
 
                                            }
300
300
 
                                        else throw("Strict value is not equal to itself.")
301
301
 
                                    }
302
302
 
                                else throw("Strict value is not equal to itself.")
303
303
 
                            }
304
304
 
                        else throw("Strict value is not equal to itself.")
305
305
 
                    }
306
306
 
                else throw("Strict value is not equal to itself.")
307
307
 
            }
308
308
 
        else throw("Strict value is not equal to itself.")
309
309
 
    }
310
310
 
311
311
 
312
312
 
313
313
 
@Callable(i)
314
314
 
func setAdmins (adminPubKeys) = {
315
315
 
    let checkCaller = mustManager(i)
316
316
 
    if ((checkCaller == checkCaller))
317
317
 
        then [StringEntry(keyAdminPubKeys(), makeString(adminPubKeys, SEP))]
318
318
 
        else throw("Strict value is not equal to itself.")
319
319
 
    }
320
320
 
321
321
 
322
322
 
323
323
 
@Callable(i)
324
324
 
func setManager (pendingManagerPublicKey) = {
325
325
 
    let checkCaller = mustManager(i)
326
326
 
    if ((checkCaller == checkCaller))
327
327
 
        then {
328
328
 
            let checkManagerPublicKey = fromBase58String(pendingManagerPublicKey)
329
329
 
            if ((checkManagerPublicKey == checkManagerPublicKey))
330
330
 
                then [StringEntry(keyPendingManagerPublicKey(), pendingManagerPublicKey)]
331
331
 
                else throw("Strict value is not equal to itself.")
332
332
 
            }
333
333
 
        else throw("Strict value is not equal to itself.")
334
334
 
    }
335
335
 
336
336
 
337
337
 
338
338
 
@Callable(i)
339
339
 
func confirmManager () = {
340
340
 
    let pm = pendingManagerPublicKeyOrUnit()
341
341
 
    let hasPM = if (isDefined(pm))
342
342
 
        then true
343
343
 
        else throw("No pending manager")
344
344
 
    if ((hasPM == hasPM))
345
345
 
        then {
346
346
 
            let checkPM = if ((i.callerPublicKey == value(pm)))
347
347
 
                then true
348
348
 
                else throw("You are not pending manager")
349
349
 
            if ((checkPM == checkPM))
350
350
 
                then [StringEntry(keyManagerPublicKey(), toBase58String(value(pm))), DeleteEntry(keyPendingManagerPublicKey())]
351
351
 
                else throw("Strict value is not equal to itself.")
352
352
 
            }
353
353
 
        else throw("Strict value is not equal to itself.")
354
354
 
    }
355
355
 
356
356
 
357
357
 
358
358
 
@Callable(i)
359
359
 
func priceAssetsREADONLY () = $Tuple2(nil, stringOptionToList(getString(keyPriceAssets())))
360
360
 
361
361
 
362
362
 
363
363
 
@Callable(i)
364
364
 
func statusREADONLY (amountAssetId,priceAssetId) = {
365
365
 
    let status =     match getString(keyStatus(amountAssetId, priceAssetId)) {
366
366
 
        case s: String => 
367
367
 
            s
368
368
 
        case _ => 
369
369
 
            unit
370
370
 
    }
371
371
 
    $Tuple2(nil, status)
372
372
 
    }
373
373
 
374
374
 
375
375
 
@Verifier(tx)
376
376
 
func verify () = {
377
377
 
    let targetPublicKey =     match managerPublicKeyOrUnit() {
378
378
 
        case pk: ByteVector => 
379
379
 
            pk
380
380
 
        case _: Unit => 
381
381
 
            tx.senderPublicKey
382
382
 
        case _ => 
383
383
 
            throw("Match error")
384
384
 
    }
385
385
 
    sigVerify(tx.bodyBytes, tx.proofs[0], targetPublicKey)
386
386
 
    }
387
387
 

github/deemru/w8io/026f985 
84.02 ms ◑