ವೇವ್ಸ್ ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳ ಅಪ್ಲಿಕೇಶನ್: ಹರಾಜಿನಿಂದ ಬೋನಸ್ ಕಾರ್ಯಕ್ರಮಗಳವರೆಗೆ

ಬ್ಲಾಕ್ಚೈನ್ ಸಾಮಾನ್ಯವಾಗಿ ಕ್ರಿಪ್ಟೋಕರೆನ್ಸಿಗಳೊಂದಿಗೆ ಮಾತ್ರ ಸಂಬಂಧಿಸಿದೆ, ಆದರೆ DLT ತಂತ್ರಜ್ಞಾನದ ಅನ್ವಯದ ಕ್ಷೇತ್ರಗಳು ಹೆಚ್ಚು ವಿಸ್ತಾರವಾಗಿವೆ. ಬ್ಲಾಕ್‌ಚೈನ್‌ನ ಬಳಕೆಗೆ ಅತ್ಯಂತ ಭರವಸೆಯ ಕ್ಷೇತ್ರಗಳಲ್ಲಿ ಒಂದು ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವಾಗಿದ್ದು ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅದರಲ್ಲಿ ಪ್ರವೇಶಿಸಿದ ಪಕ್ಷಗಳ ನಡುವೆ ನಂಬಿಕೆಯ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

ರೈಡ್ - ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಿಗೆ ಒಂದು ಭಾಷೆ

ವೇವ್ಸ್ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಿಗೆ ವಿಶೇಷ ಭಾಷೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದೆ - ರೈಡ್. ಇದರ ಸಂಪೂರ್ಣ ದಾಖಲಾತಿ ಇದೆ ಇಲ್ಲಿ. ಮತ್ತು ಇಲ್ಲಿ - ಈ ವಿಷಯದ ಬಗ್ಗೆ ಲೇಖನ ಹಬರ್ ಮೇಲೆ.

ರೈಡ್ ಒಪ್ಪಂದವು ಮುನ್ಸೂಚನೆಯಾಗಿದೆ ಮತ್ತು ಔಟ್‌ಪುಟ್‌ನಂತೆ "ನಿಜ" ಅಥವಾ "ಸುಳ್ಳು" ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಅಂತೆಯೇ, ವಹಿವಾಟನ್ನು ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ದಾಖಲಿಸಲಾಗುತ್ತದೆ ಅಥವಾ ತಿರಸ್ಕರಿಸಲಾಗುತ್ತದೆ. ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಷರತ್ತುಗಳ ನೆರವೇರಿಕೆಯನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಖಾತರಿಪಡಿಸುತ್ತದೆ. RIDE ನಲ್ಲಿನ ಒಪ್ಪಂದದಿಂದ ವಹಿವಾಟುಗಳನ್ನು ರಚಿಸುವುದು ಪ್ರಸ್ತುತ ಸಾಧ್ಯವಿಲ್ಲ.

ಇಂದು ಎರಡು ರೀತಿಯ ವೇವ್ಸ್ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳಿವೆ: ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳು ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳು. ಸ್ಮಾರ್ಟ್ ಖಾತೆಯು ಸಾಮಾನ್ಯ ಬಳಕೆದಾರ ಖಾತೆಯಾಗಿದೆ, ಆದರೆ ಎಲ್ಲಾ ವಹಿವಾಟುಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ. ಸ್ಮಾರ್ಟ್ ಖಾತೆಯ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ:

match tx {
  case t: TransferTransaction | MassTransferTransaction => false
  case _ => true
}

tx ಎನ್ನುವುದು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತಿರುವ ವ್ಯವಹಾರವಾಗಿದ್ದು, ಇದು ವರ್ಗಾವಣೆ ವಹಿವಾಟು ಅಲ್ಲದಿದ್ದಲ್ಲಿ ಮಾತ್ರ ನಮೂನೆ ಹೊಂದಾಣಿಕೆಯ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಲು ನಾವು ಅನುಮತಿಸುತ್ತೇವೆ. ವಹಿವಾಟಿನ ಪ್ರಕಾರವನ್ನು ಪರಿಶೀಲಿಸಲು RIDE ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಎಲ್ಲಾ ಖಾತೆಗಳನ್ನು ಸ್ಮಾರ್ಟ್ ಖಾತೆ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು ವಹಿವಾಟಿನ ಪ್ರಕಾರಗಳು.

ಸ್ಕ್ರಿಪ್ಟ್ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಘೋಷಿಸಬಹುದು, ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಶೀಲಿಸಲು "ಇಫ್-ಥೆನ್-ಇಲ್" ರಚನೆಗಳು ಮತ್ತು ಇತರ ವಿಧಾನಗಳನ್ನು ಬಳಸಬಹುದು. ಒಪ್ಪಂದಗಳು ಪೂರ್ಣತೆ ಮತ್ತು ಸಂಕೀರ್ಣತೆಯನ್ನು (ವೆಚ್ಚ) ಹೊಂದಿದ್ದು, ಒಪ್ಪಂದವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು ಊಹಿಸಲು ಸುಲಭವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, RIDE ಲೂಪ್‌ಗಳು ಅಥವಾ ಜಂಪ್ ಹೇಳಿಕೆಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ.

ವೇವ್ಸ್ ಖಾತೆಗಳ ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳು "ರಾಜ್ಯದ" ಉಪಸ್ಥಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅಂದರೆ ಖಾತೆಯ ಸ್ಥಿತಿ. ಡೇಟಾ ವಹಿವಾಟುಗಳನ್ನು (ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್) ಬಳಸಿಕೊಂಡು ಖಾತೆಯ ಸ್ಥಿತಿಗೆ ನೀವು ಅನಂತ ಸಂಖ್ಯೆಯ ಜೋಡಿಗಳನ್ನು (ಕೀ, ಮೌಲ್ಯ) ಬರೆಯಬಹುದು. ಈ ಮಾಹಿತಿಯನ್ನು ನಂತರ REST API ಮೂಲಕ ಮತ್ತು ನೇರವಾಗಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.

ಪ್ರತಿ ವಹಿವಾಟು ಪುರಾವೆಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಒಳಗೊಂಡಿರಬಹುದು, ಅದರಲ್ಲಿ ಭಾಗವಹಿಸುವವರ ಸಹಿ, ಅಗತ್ಯವಿರುವ ವಹಿವಾಟಿನ ID ಇತ್ಯಾದಿಗಳನ್ನು ನಮೂದಿಸಬಹುದು.

RIDE ಮೂಲಕ ಕೆಲಸ ಮಾಡಲಾಗುತ್ತಿದೆ ಇಲ್ಲಿ ಒಪ್ಪಂದದ ಸಂಕಲನ ವೀಕ್ಷಣೆಯನ್ನು ನೋಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ (ಅದನ್ನು ಸಂಕಲಿಸಿದರೆ), ಹೊಸ ಖಾತೆಗಳನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದಕ್ಕೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿಸಿ, ಹಾಗೆಯೇ ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ವಹಿವಾಟುಗಳನ್ನು ಕಳುಹಿಸಿ.

ಖಾತೆಯನ್ನು ರಚಿಸುವುದು, ಅದರ ಮೇಲೆ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದವನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮತ್ತು ವಹಿವಾಟುಗಳನ್ನು ಕಳುಹಿಸುವುದು ಸೇರಿದಂತೆ ಪೂರ್ಣ ಚಕ್ರಕ್ಕಾಗಿ, ನೀವು REST API ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಲೈಬ್ರರಿಯನ್ನು ಸಹ ಬಳಸಬಹುದು (ಉದಾಹರಣೆಗೆ, C#, C, Java, JavaScript, Python, Rust, Elixir) . IDE ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಲು, ಹೊಸ ಬಟನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ.

ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳನ್ನು ಬಳಸುವ ಸಾಧ್ಯತೆಗಳು ವಿಶಾಲವಾಗಿವೆ: ವಹಿವಾಟುಗಳನ್ನು ನಿಷೇಧಿಸುವುದರಿಂದ ಕೆಲವು ವಿಳಾಸಗಳಿಗೆ ("ಕಪ್ಪು ಪಟ್ಟಿ") ಸಂಕೀರ್ಣ dApps ವರೆಗೆ.

ಈಗ ವ್ಯವಹಾರದಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳ ಬಳಕೆಯ ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ: ಹರಾಜು, ವಿಮೆ ಮತ್ತು ನಿಷ್ಠೆ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ರಚಿಸುವಾಗ.

ಹರಾಜುಗಳು

ಯಶಸ್ವಿ ಹರಾಜಿಗೆ ಒಂದು ಷರತ್ತು ಪಾರದರ್ಶಕತೆಯಾಗಿದೆ: ಭಾಗವಹಿಸುವವರು ಬಿಡ್‌ಗಳನ್ನು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸುವುದು ಅಸಾಧ್ಯವೆಂದು ವಿಶ್ವಾಸ ಹೊಂದಿರಬೇಕು. ಬ್ಲಾಕ್‌ಚೈನ್‌ಗೆ ಧನ್ಯವಾದಗಳು ಇದನ್ನು ಸಾಧಿಸಬಹುದು, ಅಲ್ಲಿ ಎಲ್ಲಾ ಪಂತಗಳ ಬಗ್ಗೆ ಬದಲಾಗದ ಡೇಟಾ ಮತ್ತು ಅವರು ಮಾಡಿದ ಸಮಯದ ಎಲ್ಲಾ ಭಾಗವಹಿಸುವವರಿಗೆ ಲಭ್ಯವಿರುತ್ತದೆ.

ವೇವ್ಸ್ ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ, ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಮೂಲಕ ಹರಾಜು ಖಾತೆಯ ಸ್ಥಿತಿಯಲ್ಲಿ ಬಿಡ್‌ಗಳನ್ನು ದಾಖಲಿಸಬಹುದು.

ಬ್ಲಾಕ್ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಹರಾಜಿನ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಸಮಯವನ್ನು ಸಹ ಹೊಂದಿಸಬಹುದು: ವೇವ್ಸ್ ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿನ ಬ್ಲಾಕ್ ಉತ್ಪಾದನೆಯ ಆವರ್ತನವು ಸರಿಸುಮಾರು ಸಮಾನವಾಗಿರುತ್ತದೆ 60 ಸೆಕೆಂಡುಗಳು.

1. ಇಂಗ್ಲೀಷ್ ಆರೋಹಣ ಬೆಲೆ ಹರಾಜು

ಇಂಗ್ಲಿಷ್ ಹರಾಜಿನಲ್ಲಿ ಭಾಗವಹಿಸುವವರು ಪರಸ್ಪರ ಸ್ಪರ್ಧೆಯಲ್ಲಿ ಬಿಡ್ ಮಾಡುತ್ತಾರೆ. ಪ್ರತಿ ಹೊಸ ಪಂತವು ಹಿಂದಿನದನ್ನು ಮೀರಬೇಕು. ಕೊನೆಯ ಬಿಡ್‌ಗಿಂತ ಹೆಚ್ಚಿನ ಬಿಡ್‌ದಾರರು ಇಲ್ಲದಿದ್ದಾಗ ಹರಾಜು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಹೆಚ್ಚಿನ ಬಿಡ್ದಾರರು ಹೇಳಲಾದ ಮೊತ್ತವನ್ನು ಒದಗಿಸಬೇಕು.

ಮಾರಾಟಗಾರನು ಲಾಟ್‌ಗೆ ಕನಿಷ್ಠ ಬೆಲೆಯನ್ನು ನಿಗದಿಪಡಿಸುವ ಹರಾಜು ಆಯ್ಕೆಯೂ ಇದೆ ಮತ್ತು ಅಂತಿಮ ಬೆಲೆ ಅದನ್ನು ಮೀರಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಬಹಳಷ್ಟು ಮಾರಾಟವಾಗದೆ ಉಳಿಯುತ್ತದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಹರಾಜಿಗಾಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ರಚಿಸಲಾದ ಖಾತೆಯೊಂದಿಗೆ ನಾವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಹರಾಜು ಅವಧಿಯು 3000 ಬ್ಲಾಕ್‌ಗಳು, ಮತ್ತು ಲಾಟ್‌ನ ಆರಂಭಿಕ ಬೆಲೆ 0,001 ಅಲೆಗಳು. ಭಾಗವಹಿಸುವವರು "ಬೆಲೆ" ಮತ್ತು ಅವರ ಬಿಡ್‌ನ ಮೌಲ್ಯದೊಂದಿಗೆ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಕಳುಹಿಸುವ ಮೂಲಕ ಬಿಡ್ ಅನ್ನು ಇರಿಸಬಹುದು.

ಹೊಸ ಬಿಡ್‌ನ ಬೆಲೆಯು ಈ ಕೀಲಿಗಾಗಿ ಪ್ರಸ್ತುತ ಬೆಲೆಗಿಂತ ಹೆಚ್ಚಾಗಿರಬೇಕು ಮತ್ತು ಭಾಗವಹಿಸುವವರು ಕನಿಷ್ಟ [new_bid + ಕಮಿಷನ್] ಟೋಕನ್‌ಗಳನ್ನು ಅವರ ಖಾತೆಯಲ್ಲಿ ಹೊಂದಿರಬೇಕು. ಬಿಡ್ದಾರರ ವಿಳಾಸವನ್ನು ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್‌ನಲ್ಲಿ "ಕಳುಹಿಸುವವರ" ಕ್ಷೇತ್ರದಲ್ಲಿ ದಾಖಲಿಸಬೇಕು ಮತ್ತು ಪ್ರಸ್ತುತ ಬಿಡ್ ಬ್ಲಾಕ್ ಎತ್ತರವು ಹರಾಜು ಅವಧಿಯೊಳಗೆ ಇರಬೇಕು.

ಹರಾಜಿನ ಕೊನೆಯಲ್ಲಿ ಭಾಗವಹಿಸುವವರು ಅತ್ಯಧಿಕ ಬೆಲೆಯನ್ನು ನಿಗದಿಪಡಿಸಿದರೆ, ಅವರು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಬೆಲೆ ಮತ್ತು ಕರೆನ್ಸಿ ಜೋಡಿಯಲ್ಲಿ ಅನುಗುಣವಾದ ಲಾಟ್‌ಗೆ ಪಾವತಿಸಲು ವಿನಿಮಯ ವಹಿವಾಟನ್ನು ಕಳುಹಿಸಬಹುದು.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
match tx {
case d : DataTransaction =>
  #проверяем, задана ли в стейте цена
  let currentPrice = if isDefined(getInteger(this, "price"))
 
                      #извлекаем цену из стейта
                      then extract(getInteger(this, "price"))
                      else startPrice
 
  #извлекаем цену из транзакции
  let newPrice = extract(getInteger(d.data, "price"))
  let priceIsBigger = newPrice > currentPrice
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции два поля и что отправитель совпадает с указанным в транзакции
  let correctFields = size(d.data) == 2 &&      
      d.sender == addressFromString(extract(getString(d.data,"sender")))
  startHeight <= height && height <= finishHeight && priceIsBigger && hasMoney && correctFields
case e : ExchangeTransaction =>
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender"))) #убеждаемся, что лот обменивает тот, кто его выиграл
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
 
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

2. ಕಡಿಮೆಯಾಗುತ್ತಿರುವ ಬೆಲೆಗಳ ಡಚ್ ಹರಾಜು

ಡಚ್ ಹರಾಜಿನಲ್ಲಿ, ಖರೀದಿದಾರನು ಪಾವತಿಸಲು ಸಿದ್ಧರಿದ್ದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಬೆಲೆಗೆ ಆರಂಭದಲ್ಲಿ ಬಹಳಷ್ಟು ನೀಡಲಾಗುತ್ತದೆ. ಭಾಗವಹಿಸುವವರಲ್ಲಿ ಒಬ್ಬರು ಪ್ರಸ್ತುತ ಬೆಲೆಗೆ ಲಾಟ್ ಅನ್ನು ಖರೀದಿಸಲು ಒಪ್ಪಿಕೊಳ್ಳುವವರೆಗೆ ಬೆಲೆಯನ್ನು ಹಂತ ಹಂತವಾಗಿ ಕಡಿಮೆಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಹಿಂದಿನ ಒಂದೇ ಸ್ಥಿರಾಂಕಗಳನ್ನು ಬಳಸುತ್ತೇವೆ, ಹಾಗೆಯೇ ಡೆಲ್ಟಾ ಕಡಿಮೆಯಾದಾಗ ಬೆಲೆ ಹಂತವನ್ನು ಬಳಸುತ್ತೇವೆ. ಖಾತೆಯ ಸ್ಕ್ರಿಪ್ಟ್ ಭಾಗವಹಿಸುವವರು ನಿಜವಾಗಿಯೂ ಪಂತವನ್ನು ಹಾಕುವ ಮೊದಲಿಗರೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಬ್ಲಾಕ್‌ಚೈನ್‌ನಿಂದ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲಾಗುವುದಿಲ್ಲ.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000000
let delta = 100
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d : DataTransaction =>
  let currentPrice = startPrice - delta * (height - startHeight)
 
  #извлекаем из поступившей дата-транзакции поле "price"
  let newPrice = extract(getInteger(d.data, "price"))
 
  #убеждаемся, что в стейте текущего аккаунта не содержится поля "sender"
  let noBetsBefore = !isDefined(getInteger(this, "sender"))
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции только два поля
  let correctFields = size(d.data) == 2 && newPrice == currentPrice && d.sender == addressFromString(extract(getString(d.data, "sender")))
  startHeight <= height && height <= finishHeight && noBetsBefore && hasMoney && correctFields
case e : ExchangeTransaction =>
 
  #убеждаемся, что отправитель текущей транзакции указан в стейте аккаунта по ключу sender
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender")))
 
  #убеждаемся, что аmount ассета указан корректно, и что прайс-ассет - waves
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

3. ಹರಾಜು "ಎಲ್ಲಾ-ಪಾವತಿ"

"ಆಲ್-ಪೇ" ಎನ್ನುವುದು ಹರಾಜಾಗಿದ್ದು, ಇದರಲ್ಲಿ ಭಾಗವಹಿಸುವವರು ಯಾರು ಬಹಳಷ್ಟು ಗೆಲ್ಲುತ್ತಾರೆ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ ಬಿಡ್ ಅನ್ನು ಪಾವತಿಸುತ್ತಾರೆ. ಪ್ರತಿಯೊಬ್ಬ ಹೊಸ ಭಾಗವಹಿಸುವವರು ಬಿಡ್ ಅನ್ನು ಪಾವತಿಸುತ್ತಾರೆ ಮತ್ತು ಗರಿಷ್ಠ ಬಿಡ್ ಮಾಡುವ ಪಾಲ್ಗೊಳ್ಳುವವರು ಬಹಳಷ್ಟು ಗೆಲ್ಲುತ್ತಾರೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪ್ರತಿ ಹರಾಜಿನಲ್ಲಿ ಭಾಗವಹಿಸುವವರು (ಕೀ, ಮೌಲ್ಯ)* = (“ವಿಜೇತ”, ವಿಳಾಸ), (“ಬೆಲೆ”, ಬೆಲೆ) ಜೊತೆಗೆ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಮೂಲಕ ಬಿಡ್ ಅನ್ನು ಇರಿಸುತ್ತಾರೆ. ಈ ಭಾಗವಹಿಸುವವರು ಈಗಾಗಲೇ ಅವರ ಸಹಿಯೊಂದಿಗೆ ವರ್ಗಾವಣೆ ವಹಿವಾಟನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ಅವರ ಬಿಡ್ ಹಿಂದಿನ ಎಲ್ಲಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ ಮಾತ್ರ ಅಂತಹ ಡೇಟಾ ವಹಿವಾಟನ್ನು ಅನುಮೋದಿಸಲಾಗುತ್ತದೆ. ಅಂತಿಮ ಎತ್ತರವನ್ನು ತಲುಪುವವರೆಗೆ ಹರಾಜು ಮುಂದುವರಿಯುತ್ತದೆ.

let startHeight = 1000
let endHeight = 2000
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
 case d: DataTransaction =>
   #извлекаем из поступившей дата-транзакции поле "price"
   let newPrice = extract(getInteger(d.data, "price"))
 
   #извлекаем из пруфов транзакции публичный ключ аккаунта
   let pk = d.proofs[1]
   let address = addressFromPublicKey(pk)
 
   #извлекаем транзакцию доказательство из пруфов поступившей дата транзакции
   let proofTx = extract(transactionById(d.proofs[2]))
   
   height > startHeight && height < endHeight
   && size(d.data) == 2
   #убеждаемся, что адрес победителя, извлеченный из текущей транзакции, совпадает с адресом, извлеченным из пруфов
   && extract(getString(d.data, "winner")) == toBase58String(address.bytes)
   && newPrice > extract(getInteger(this, "price"))
   #проверяем, что транзакция подписана
   && sigVerify(d.bodyBytes, d.proofs[0], d.proofs[1])
   #проверяем корректность транзакции, указанной в пруфах
   && match proofTx {
     case tr : TransferTransaction =>
       tr.sender == address &&
       tr.amount == newPrice
     case _ => false
   }
 case t: TransferTransaction =>
 sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
 || (
   height > endHeight
   && extract(getString(this, "winner")) == toBase58String((addressFromRecipient(t.recipient)).bytes)
   && t.assetId == token
   && t.amount == 1
 )
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

ವಿಮೆ / ಕ್ರೌಡ್‌ಫಂಡಿಂಗ್

ಹಣಕಾಸಿನ ನಷ್ಟಗಳ ವಿರುದ್ಧ ಬಳಕೆದಾರರ ಸ್ವತ್ತುಗಳನ್ನು ನೀವು ವಿಮೆ ಮಾಡಬೇಕಾದ ಪರಿಸ್ಥಿತಿಯನ್ನು ಪರಿಗಣಿಸೋಣ. ಉದಾಹರಣೆಗೆ, ಟೋಕನ್ ಸವಕಳಿ ಮಾಡಿದರೆ, ಈ ಟೋಕನ್‌ಗಳಿಗೆ ಪಾವತಿಸಿದ ಪೂರ್ಣ ಮೊತ್ತವನ್ನು ಮರಳಿ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಮತ್ತು ಸಮಂಜಸವಾದ ವಿಮೆಯನ್ನು ಪಾವತಿಸಲು ಸಿದ್ಧರಿದ್ದಾರೆ ಎಂಬ ಖಾತರಿಯನ್ನು ಬಳಕೆದಾರರು ಬಯಸುತ್ತಾರೆ.

ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, "ವಿಮೆ ಟೋಕನ್ಗಳನ್ನು" ನೀಡಬೇಕಾಗಿದೆ. ನಂತರ ಪಾಲಿಸಿದಾರರ ಖಾತೆಯಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವ ವಿನಿಮಯ ವಹಿವಾಟುಗಳನ್ನು ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.

ದುಪ್ಪಟ್ಟು ಖರ್ಚು ಮಾಡುವುದನ್ನು ತಡೆಯಲು, (ಕೀ, ಮೌಲ್ಯ) = (ಖರೀದಿ ವಹಿವಾಟು ಐಡಿ, ಮಾರಾಟ ಆರ್ಡರ್ಐಡಿ) ಜೊತೆಗೆ ಪಾಲಿಸಿದಾರರ ಖಾತೆಗೆ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಕಳುಹಿಸಲು ನೀವು ಬಳಕೆದಾರರನ್ನು ವಿನಂತಿಸಬೇಕು ಮತ್ತು ಈಗಾಗಲೇ ಬಳಸಿರುವ ಕೀಲಿಯೊಂದಿಗೆ ಡೇಟಾ ವಹಿವಾಟುಗಳನ್ನು ಕಳುಹಿಸುವುದನ್ನು ನಿಷೇಧಿಸಬೇಕು.

ಆದ್ದರಿಂದ, ಬಳಕೆದಾರರ ಪುರಾವೆಗಳು ವಿಮಾ ಟೋಕನ್ ಖರೀದಿಯ ವಹಿವಾಟು ಐಡಿಯನ್ನು ಹೊಂದಿರಬೇಕು. ಕರೆನ್ಸಿ ಜೋಡಿಯು ಖರೀದಿ ವಹಿವಾಟಿನಂತೆಯೇ ಇರಬೇಕು. ವಿಮೆಯ ಬೆಲೆಯನ್ನು ಕಳೆದು ಖರೀದಿಸುವ ಸಮಯದಲ್ಲಿ ನಿಗದಿಪಡಿಸಿದ ವೆಚ್ಚಕ್ಕೆ ಸಮನಾಗಿರಬೇಕು.

ತರುವಾಯ ವಿಮಾ ಖಾತೆಯು ಬಳಕೆದಾರರಿಂದ ವಿಮಾ ಟೋಕನ್‌ಗಳನ್ನು ಅವರು ಖರೀದಿಸಿದ ಬೆಲೆಗಿಂತ ಕಡಿಮೆಯಿಲ್ಲದ ಬೆಲೆಗೆ ಖರೀದಿಸುತ್ತದೆ ಎಂದು ತಿಳಿಯಲಾಗಿದೆ: ವಿಮಾ ಖಾತೆಯು ಎಕ್ಸ್‌ಚೇಂಜ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ, ಬಳಕೆದಾರರು ಆದೇಶಕ್ಕೆ ಸಹಿ ಹಾಕುತ್ತಾರೆ (ವಹಿವಾಟು ಸರಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡರೆ), ವಿಮಾ ಖಾತೆಯು ಎರಡನೇ ಆದೇಶ ಮತ್ತು ಸಂಪೂರ್ಣ ವಹಿವಾಟಿಗೆ ಸಹಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಬ್ಲಾಕ್‌ಚೈನ್‌ಗೆ ಕಳುಹಿಸುತ್ತದೆ.

ಯಾವುದೇ ಖರೀದಿ ಸಂಭವಿಸದಿದ್ದರೆ, ಬಳಕೆದಾರರು ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ವಿವರಿಸಿದ ನಿಯಮಗಳ ಪ್ರಕಾರ ವಿನಿಮಯ ವಹಿವಾಟನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ವಹಿವಾಟನ್ನು ಬ್ಲಾಕ್‌ಚೈನ್‌ಗೆ ಕಳುಹಿಸಬಹುದು. ಈ ರೀತಿಯಲ್ಲಿ ಬಳಕೆದಾರರು ವಿಮೆ ಮಾಡಿದ ಟೋಕನ್‌ಗಳ ಖರೀದಿಗೆ ಖರ್ಚು ಮಾಡಿದ ಹಣವನ್ನು ಹಿಂದಿರುಗಿಸಬಹುದು.

let insuranceToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let freezePeriod = 150000
let insurancePrice = 10000
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : ExchangeTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : ExchangeTransaction =>
         let correctSender = purchase.sender == e.sellOrder.sender
         let correctAssetPair = e.sellOrder.assetPair.amountAsset == insuranceToken &&
                                purchase.sellOrder.assetPair.amountAsset == insuranceToken &&
                                e.sellOrder.assetPair.priceAsset == purchase.sellOrder.assetPair.priceAsset
         let correctPrice = e.price == purchase.price - insurancePrice && e.amount == purchase.amount
         let correctHeight = height > purchaseTxHeight + freezePeriod
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.sellOrder.id
         correctSender && correctAssetPair && correctPrice && correctHeight && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

ವಿಮಾ ಟೋಕನ್ ಅನ್ನು ಸ್ಮಾರ್ಟ್ ಆಸ್ತಿಯನ್ನಾಗಿ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, ಮೂರನೇ ವ್ಯಕ್ತಿಗಳಿಗೆ ಅದರ ವರ್ಗಾವಣೆಯನ್ನು ನಿಷೇಧಿಸಲು.

ಈ ಯೋಜನೆಯನ್ನು ಕ್ರೌಡ್‌ಫಂಡಿಂಗ್ ಟೋಕನ್‌ಗಳಿಗಾಗಿ ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು, ಅಗತ್ಯವಿರುವ ಮೊತ್ತವನ್ನು ಸಂಗ್ರಹಿಸದಿದ್ದರೆ ಮಾಲೀಕರಿಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.

ವಹಿವಾಟು ತೆರಿಗೆಗಳು

ಹಲವಾರು ರೀತಿಯ ಸ್ವತ್ತುಗಳೊಂದಿಗೆ ಪ್ರತಿ ವಹಿವಾಟಿನ ಮೇಲೆ ತೆರಿಗೆ ಸಂಗ್ರಹಿಸಲು ಅಗತ್ಯವಿರುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಒಪ್ಪಂದಗಳು ಸಹ ಅನ್ವಯಿಸುತ್ತವೆ. ಸ್ಥಾಪಿಸಲಾದ ಹೊಸ ಸ್ವತ್ತಿನ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು ಪ್ರಾಯೋಜಕತ್ವ ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳೊಂದಿಗೆ ವಹಿವಾಟುಗಳಿಗಾಗಿ:

1. ನಾವು FeeCoin ಅನ್ನು ನೀಡುತ್ತೇವೆ, ಇದನ್ನು ಬಳಕೆದಾರರಿಗೆ ನಿಗದಿತ ಬೆಲೆಗೆ ಕಳುಹಿಸಲಾಗುವುದು: 0,01 WAVES = 0,001 FeeCoin.

2. FeeCoin ಮತ್ತು ವಿನಿಮಯ ದರಕ್ಕೆ ಪ್ರಾಯೋಜಕತ್ವವನ್ನು ಹೊಂದಿಸಿ: 0,001 WAVES = 0,001 FeeCoin.

3. ಸ್ಮಾರ್ಟ್ ಆಸ್ತಿಗಾಗಿ ಈ ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಿ:

let feeAssetId = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let taxDivisor = 10
 
match tx {
  case t: TransferTransaction =>
    t.feeAssetId == feeAssetId && t.fee == t.amount / taxDivisor
  case e: ExchangeTransaction | MassTransferTransaction => false
  case _ => true
}

ಈಗ ಪ್ರತಿ ಬಾರಿ ಯಾರಾದರೂ N ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳನ್ನು ವರ್ಗಾಯಿಸಿದಾಗ, ಅವರು ನಿಮಗೆ N/taxDivisor ಮೊತ್ತದಲ್ಲಿ FeeCoin ಅನ್ನು ನೀಡುತ್ತಾರೆ (ಅದನ್ನು ನಿಮ್ಮಿಂದ 10 *N/taxDivisor WAVES ನಲ್ಲಿ ಖರೀದಿಸಬಹುದು), ಮತ್ತು ನೀವು ಮೈನರ್ N/taxDivisor ವೇವ್‌ಗಳನ್ನು ನೀಡುತ್ತೀರಿ. ಪರಿಣಾಮವಾಗಿ, ನಿಮ್ಮ ಲಾಭ (ತೆರಿಗೆ) 9*N / ತೆರಿಗೆ ವಿಭಾಜಕ ಅಲೆಗಳಾಗಿರುತ್ತದೆ.

ನೀವು ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು ಮಾಸ್ ಟ್ರಾನ್ಸ್ಫರ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ತೆರಿಗೆಯನ್ನು ಮಾಡಬಹುದು:

let taxDivisor = 10
 
match tx {
  case t : MassTransferTransaction =>
    let twoTransfers = size(t.transfers) == 2
    let issuerIsRecipient = t.transfers[0].recipient == addressFromString("3MgkTXzD72BTfYpd9UW42wdqTVg8HqnXEfc")
    let taxesPaid = t.transfers[0].amount >= t.transfers[1].amount / taxDivisor
    twoTransfers && issuerIsRecipient && taxesPaid
  case _ => false
}

ಕ್ಯಾಶ್ಬ್ಯಾಕ್ ಮತ್ತು ಲಾಯಲ್ಟಿ ಕಾರ್ಯಕ್ರಮಗಳು

ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಎನ್ನುವುದು ಒಂದು ರೀತಿಯ ಲಾಯಲ್ಟಿ ಪ್ರೋಗ್ರಾಂ ಆಗಿದ್ದು, ಇದರಲ್ಲಿ ಖರೀದಿದಾರರು ಉತ್ಪನ್ನ ಅಥವಾ ಸೇವೆಗೆ ಖರ್ಚು ಮಾಡಿದ ಮೊತ್ತದ ಭಾಗವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತಾರೆ.

ಸ್ಮಾರ್ಟ್ ಖಾತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಪ್ರಕರಣವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ವಿಮೆ ಪ್ರಕರಣದಲ್ಲಿ ನಾವು ಮಾಡಿದ ರೀತಿಯಲ್ಲಿಯೇ ನಾವು ಪುರಾವೆಗಳನ್ನು ಪರಿಶೀಲಿಸಬೇಕು. ಎರಡು ಬಾರಿ ಖರ್ಚು ಮಾಡುವುದನ್ನು ತಡೆಯಲು, ಬಳಕೆದಾರರು ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಸ್ವೀಕರಿಸುವ ಮೊದಲು (ಕೀ, ಮೌಲ್ಯ) = (ಖರೀದಿ ವಹಿವಾಟು ಐಡಿ, ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಐಡಿ) ನೊಂದಿಗೆ ಡೇಟಾ ವಹಿವಾಟನ್ನು ಕಳುಹಿಸಬೇಕು.

ನಾವು ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಕೀಗಳ ಮೇಲೆ ನಿಷೇಧವನ್ನು ಹೊಂದಿಸಬೇಕು. ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಡಿವೈಸರ್ - ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಷೇರಿನಿಂದ ಭಾಗಿಸಿದ ಘಟಕ. ಆ. ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಷೇರು 0.1 ಆಗಿದ್ದರೆ, ನಂತರ ಕ್ಯಾಶ್‌ಬ್ಯಾಕ್ ಡಿವೈಸರ್ 1 / 0.1 = 10.

let cashbackToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let cashbackDivisor = 10
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : TransferTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
 
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : TransferTransaction =>
         let correctSender = purchase.sender == e.sender
         let correctAsset = e.assetId == cashbackToken
         let correctPrice = e.amount == purchase.amount / cashbackDivisor
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.id
         correctSender && correctAsset && correctPrice && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

ಪರಮಾಣು ಸ್ವಾಪ್

ಪರಮಾಣು ಸ್ವಾಪ್ ಬಳಕೆದಾರರಿಗೆ ವಿನಿಮಯದ ಸಹಾಯವಿಲ್ಲದೆ ಸ್ವತ್ತುಗಳನ್ನು ವಿನಿಮಯ ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ಪರಮಾಣು ಸ್ವಾಪ್ನೊಂದಿಗೆ, ವಹಿವಾಟಿನಲ್ಲಿ ಭಾಗವಹಿಸುವ ಇಬ್ಬರೂ ನಿರ್ದಿಷ್ಟ ಸಮಯದೊಳಗೆ ಅದನ್ನು ದೃಢೀಕರಿಸುವ ಅಗತ್ಯವಿದೆ.

ವಹಿವಾಟಿಗೆ ನಿಗದಿಪಡಿಸಿದ ಸಮಯದೊಳಗೆ ಭಾಗವಹಿಸುವವರಲ್ಲಿ ಕನಿಷ್ಠ ಒಬ್ಬರು ವಹಿವಾಟಿನ ಸರಿಯಾದ ದೃಢೀಕರಣವನ್ನು ಒದಗಿಸದಿದ್ದರೆ, ವಹಿವಾಟು ರದ್ದುಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ವಿನಿಮಯವು ಸಂಭವಿಸುವುದಿಲ್ಲ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಈ ಕೆಳಗಿನ ಸ್ಮಾರ್ಟ್ ಖಾತೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ:

let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
 
let beforeHeight = 100000
 
let secret = base58'BN6RTYGWcwektQfSFzH8raYo9awaLgQ7pLyWLQY4S4F5'
match tx {
  case t: TransferTransaction =>
    let txToBob = t.recipient == Bob && sha256(t.proofs[0]) == secret && 20 + beforeHeight >= height
    let backToAliceAfterHeight = height >= 21 + beforeHeight && t.recipient == Alice
    txToBob || backToAliceAfterHeight
  case _ => false
}

ಮುಂದಿನ ಲೇಖನದಲ್ಲಿ ನಾವು ಆಯ್ಕೆಗಳು, ಭವಿಷ್ಯಗಳು ಮತ್ತು ಬಿಲ್‌ಗಳಂತಹ ಹಣಕಾಸು ಸಾಧನಗಳಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳ ಬಳಕೆಯನ್ನು ನೋಡೋಣ.

ಮೂಲ: www.habr.com