ਵੇਵਜ਼ ਸਮਾਰਟ ਖਾਤਿਆਂ ਦੀ ਵਰਤੋਂ: ਨਿਲਾਮੀ ਤੋਂ ਬੋਨਸ ਪ੍ਰੋਗਰਾਮਾਂ ਤੱਕ

ਬਲਾਕਚੈਨ ਅਕਸਰ ਸਿਰਫ ਕ੍ਰਿਪਟੋਕਰੰਸੀ ਨਾਲ ਜੁੜਿਆ ਹੁੰਦਾ ਹੈ, ਪਰ ਡੀਐਲਟੀ ਤਕਨਾਲੋਜੀ ਦੀ ਵਰਤੋਂ ਦੇ ਖੇਤਰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਆਪਕ ਹਨ। ਬਲੌਕਚੈਨ ਦੀ ਵਰਤੋਂ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਖੇਤਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਇੱਕ ਸਮਾਰਟ ਇਕਰਾਰਨਾਮਾ ਹੈ ਜੋ ਆਪਣੇ ਆਪ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਵਾਲੀਆਂ ਪਾਰਟੀਆਂ ਵਿਚਕਾਰ ਵਿਸ਼ਵਾਸ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

ਰਾਈਡ - ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਲਈ ਇੱਕ ਭਾਸ਼ਾ

ਵੇਵਜ਼ ਨੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ - ਰਾਈਡ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਭਾਸ਼ਾ ਵਿਕਸਿਤ ਕੀਤੀ ਹੈ। ਇਸ ਦੇ ਪੂਰੇ ਦਸਤਾਵੇਜ਼ ਮੌਜੂਦ ਹਨ ਇੱਥੇ. ਅਤੇ ਇੱਥੇ - ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਲੇਖ Habr 'ਤੇ.

ਰਾਈਡ ਇਕਰਾਰਨਾਮਾ ਇੱਕ ਵਿਵਹਾਰਕ ਹੈ ਅਤੇ ਆਉਟਪੁੱਟ ਦੇ ਰੂਪ ਵਿੱਚ "ਸੱਚ" ਜਾਂ "ਗਲਤ" ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਅਨੁਸਾਰ, ਲੈਣ-ਦੇਣ ਨੂੰ ਜਾਂ ਤਾਂ ਬਲਾਕਚੈਨ ਵਿੱਚ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਾਂ ਰੱਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਨਿਸ਼ਚਿਤ ਸ਼ਰਤਾਂ ਦੀ ਪੂਰਤੀ ਦੀ ਪੂਰੀ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ। RIDE ਵਿੱਚ ਇੱਕ ਇਕਰਾਰਨਾਮੇ ਤੋਂ ਲੈਣ-ਦੇਣ ਤਿਆਰ ਕਰਨਾ ਫਿਲਹਾਲ ਸੰਭਵ ਨਹੀਂ ਹੈ।

ਅੱਜ ਵੇਵਜ਼ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਦੀਆਂ ਦੋ ਕਿਸਮਾਂ ਹਨ: ਸਮਾਰਟ ਖਾਤੇ ਅਤੇ ਸਮਾਰਟ ਸੰਪਤੀਆਂ। ਇੱਕ ਸਮਾਰਟ ਖਾਤਾ ਇੱਕ ਨਿਯਮਤ ਉਪਭੋਗਤਾ ਖਾਤਾ ਹੈ, ਪਰ ਇਸਦੇ ਲਈ ਇੱਕ ਸਕ੍ਰਿਪਟ ਸੈੱਟ ਕੀਤੀ ਗਈ ਹੈ ਜੋ ਸਾਰੇ ਲੈਣ-ਦੇਣ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੀ ਹੈ। ਇੱਕ ਸਮਾਰਟ ਖਾਤਾ ਸਕ੍ਰਿਪਟ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈ, ਉਦਾਹਰਨ ਲਈ:

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

tx ਇੱਕ ਲੈਣ-ਦੇਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ ਜਿਸਦੀ ਅਸੀਂ ਪੈਟਰਨ ਮੈਚਿੰਗ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ ਜੇਕਰ ਇਹ ਇੱਕ ਟ੍ਰਾਂਸਫਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਨਹੀਂ ਹੈ। RIDE ਵਿੱਚ ਪੈਟਰਨ ਮੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਲੈਣ-ਦੇਣ ਦੀ ਕਿਸਮ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਸਾਰੇ ਮੌਜੂਦਾ ਖਾਤਿਆਂ 'ਤੇ ਸਮਾਰਟ ਖਾਤਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਲੈਣ-ਦੇਣ ਦੀਆਂ ਕਿਸਮਾਂ.

ਸਕ੍ਰਿਪਟ ਵੇਰੀਏਬਲ ਵੀ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦੀ ਹੈ, ਸਥਿਤੀਆਂ ਦੀ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜਾਂਚ ਕਰਨ ਲਈ "ਜੇ-ਤਾਂ-ਹੋਰ" ਰਚਨਾਵਾਂ ਅਤੇ ਹੋਰ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੀ ਹੈ। ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਕਿ ਇਕਰਾਰਨਾਮੇ ਵਿੱਚ ਸਾਬਤ ਹੋਣ ਯੋਗ ਸੰਪੂਰਨਤਾ ਅਤੇ ਜਟਿਲਤਾ (ਲਾਗਤ) ਹੈ ਜਿਸਦਾ ਇਕਰਾਰਨਾਮੇ ਦੇ ਲਾਗੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ ਆਸਾਨ ਹੈ, ਰਾਈਡ ਵਿੱਚ ਲੂਪਸ ਜਾਂ ਜੰਪ ਸਟੇਟਮੈਂਟ ਨਹੀਂ ਹਨ।

ਵੇਵਜ਼ ਖਾਤਿਆਂ ਦੀਆਂ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ "ਸਟੇਟ" ਦੀ ਮੌਜੂਦਗੀ ਸ਼ਾਮਲ ਹੈ, ਯਾਨੀ ਖਾਤੇ ਦੀ ਸਥਿਤੀ। ਤੁਸੀਂ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ (ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਖਾਤੇ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਅਨੰਤ ਗਿਣਤੀ ਵਿੱਚ ਜੋੜਿਆਂ (ਕੁੰਜੀ, ਮੁੱਲ) ਲਿਖ ਸਕਦੇ ਹੋ। ਇਸ ਜਾਣਕਾਰੀ 'ਤੇ ਫਿਰ REST API ਦੁਆਰਾ ਅਤੇ ਸਿੱਧੇ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਹਰੇਕ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਸਬੂਤਾਂ ਦੀ ਇੱਕ ਲੜੀ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਭਾਗੀਦਾਰ ਦੇ ਦਸਤਖਤ, ਲੋੜੀਂਦੇ ਲੈਣ-ਦੇਣ ਦੀ ID, ਆਦਿ ਦਰਜ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਦੁਆਰਾ RIDE ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਥੇ ਤੁਹਾਨੂੰ ਇਕਰਾਰਨਾਮੇ ਦਾ ਸੰਕਲਿਤ ਦ੍ਰਿਸ਼ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (ਜੇ ਇਹ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ), ਨਵੇਂ ਖਾਤੇ ਬਣਾਉਣ ਅਤੇ ਇਸਦੇ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਸੈੱਟ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ ਕਮਾਂਡ ਲਾਈਨ ਰਾਹੀਂ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਭੇਜਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

ਇੱਕ ਪੂਰੇ ਚੱਕਰ ਲਈ, ਇੱਕ ਖਾਤਾ ਬਣਾਉਣਾ, ਇਸ 'ਤੇ ਇੱਕ ਸਮਾਰਟ ਕੰਟਰੈਕਟ ਸਥਾਪਤ ਕਰਨਾ ਅਤੇ ਲੈਣ-ਦੇਣ ਭੇਜਣਾ ਸ਼ਾਮਲ ਹੈ, ਤੁਸੀਂ REST API (ਉਦਾਹਰਨ ਲਈ, C#, C, Java, JavaScript, Python, Rust, Elixir) ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ। . IDE ਨਾਲ ਕੰਮ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਸਿਰਫ਼ ਨਵਾਂ ਬਟਨ ਦਬਾਓ।

ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀਆਂ ਸੰਭਾਵਨਾਵਾਂ ਵਿਸ਼ਾਲ ਹਨ: ਕੁਝ ਪਤਿਆਂ ("ਕਾਲੀ ਸੂਚੀ") ਤੋਂ ਲੈ ਕੇ ਗੁੰਝਲਦਾਰ dApps ਤੱਕ ਲੈਣ-ਦੇਣ 'ਤੇ ਪਾਬੰਦੀ ਲਗਾਉਣ ਤੋਂ।

ਆਉ ਹੁਣ ਕਾਰੋਬਾਰ ਵਿੱਚ ਸਮਾਰਟ ਕੰਟਰੈਕਟਸ ਦੀ ਵਰਤੋਂ ਦੀਆਂ ਖਾਸ ਉਦਾਹਰਣਾਂ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ: ਨਿਲਾਮੀ, ਬੀਮਾ, ਅਤੇ ਵਫਾਦਾਰੀ ਪ੍ਰੋਗਰਾਮ ਬਣਾਉਣ ਵੇਲੇ।

ਨਿਲਾਮੀ

ਇੱਕ ਸਫਲ ਨਿਲਾਮੀ ਲਈ ਸ਼ਰਤਾਂ ਵਿੱਚੋਂ ਇੱਕ ਪਾਰਦਰਸ਼ਤਾ ਹੈ: ਭਾਗੀਦਾਰਾਂ ਨੂੰ ਯਕੀਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਬੋਲੀ ਵਿੱਚ ਹੇਰਾਫੇਰੀ ਕਰਨਾ ਅਸੰਭਵ ਹੈ। ਇਹ ਬਲਾਕਚੈਨ ਲਈ ਧੰਨਵਾਦ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਸਾਰੇ ਸੱਟੇਬਾਜ਼ੀ ਬਾਰੇ ਅਟੱਲ ਡਾਟਾ ਅਤੇ ਉਹ ਸਮਾਂ ਜਦੋਂ ਉਹ ਬਣਾਏ ਗਏ ਸਨ, ਸਾਰੇ ਭਾਗੀਦਾਰਾਂ ਲਈ ਉਪਲਬਧ ਹੋਣਗੇ।

ਵੇਵਜ਼ ਬਲਾਕਚੈਨ 'ਤੇ, ਬੋਲੀ ਨੂੰ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਦੁਆਰਾ ਨਿਲਾਮੀ ਖਾਤੇ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਤੁਸੀਂ ਬਲਾਕ ਨੰਬਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨਿਲਾਮੀ ਦੀ ਸ਼ੁਰੂਆਤ ਅਤੇ ਸਮਾਪਤੀ ਸਮਾਂ ਵੀ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ: ਵੇਵਜ਼ ਬਲਾਕਚੈਨ ਵਿੱਚ ਬਲਾਕ ਉਤਪਾਦਨ ਦੀ ਬਾਰੰਬਾਰਤਾ ਲਗਭਗ ਬਰਾਬਰ ਹੈ 60 ਸਕਿੰਟ

1. ਅੰਗਰੇਜ਼ੀ ਚੜ੍ਹਦੀ ਕੀਮਤ ਨਿਲਾਮੀ

ਅੰਗਰੇਜ਼ੀ ਨਿਲਾਮੀ ਵਿੱਚ ਭਾਗ ਲੈਣ ਵਾਲੇ ਇੱਕ ਦੂਜੇ ਨਾਲ ਮੁਕਾਬਲੇ ਵਿੱਚ ਬੋਲੀ ਲਗਾਉਂਦੇ ਹਨ। ਹਰੇਕ ਨਵੀਂ ਬਾਜ਼ੀ ਪਿਛਲੇ ਇੱਕ ਤੋਂ ਵੱਧ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਨਿਲਾਮੀ ਉਦੋਂ ਖਤਮ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਆਖਰੀ ਬੋਲੀ ਤੋਂ ਵੱਧ ਲਈ ਕੋਈ ਹੋਰ ਬੋਲੀਕਾਰ ਨਹੀਂ ਹੁੰਦੇ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਭ ਤੋਂ ਵੱਧ ਬੋਲੀਕਾਰ ਨੂੰ ਦੱਸੀ ਗਈ ਰਕਮ ਪ੍ਰਦਾਨ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

ਇੱਥੇ ਇੱਕ ਨਿਲਾਮੀ ਵਿਕਲਪ ਵੀ ਹੈ ਜਿਸ ਵਿੱਚ ਵਿਕਰੇਤਾ ਲਾਟ ਲਈ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਕੀਮਤ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਅੰਤਿਮ ਕੀਮਤ ਇਸ ਤੋਂ ਵੱਧ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਨਹੀਂ ਤਾਂ, ਲਾਟ ਅਣਵਿਕੀ ਰਹਿੰਦੀ ਹੈ।

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਨਿਲਾਮੀ ਲਈ ਖਾਸ ਤੌਰ 'ਤੇ ਬਣਾਏ ਗਏ ਖਾਤੇ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ। ਨਿਲਾਮੀ ਦੀ ਮਿਆਦ 3000 ਬਲਾਕ ਹੈ, ਅਤੇ ਲਾਟ ਦੀ ਸ਼ੁਰੂਆਤੀ ਕੀਮਤ 0,001 ਵੇਵ ਹੈ। ਇੱਕ ਭਾਗੀਦਾਰ ਕੁੰਜੀ "ਕੀਮਤ" ਅਤੇ ਆਪਣੀ ਬੋਲੀ ਦੇ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜ ਕੇ ਇੱਕ ਬੋਲੀ ਲਗਾ ਸਕਦਾ ਹੈ।

ਨਵੀਂ ਬੋਲੀ ਦੀ ਕੀਮਤ ਇਸ ਕੁੰਜੀ ਲਈ ਮੌਜੂਦਾ ਕੀਮਤ ਤੋਂ ਵੱਧ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਅਤੇ ਭਾਗੀਦਾਰ ਦੇ ਖਾਤੇ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ [ਨਵੀਂ ਬੋਲੀ + ਕਮਿਸ਼ਨ] ਟੋਕਨ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। ਬੋਲੀਕਾਰ ਦਾ ਪਤਾ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ "ਭੇਜਣ ਵਾਲੇ" ਖੇਤਰ ਵਿੱਚ ਦਰਜ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਮੌਜੂਦਾ ਬੋਲੀ ਬਲਾਕ ਉਚਾਈ ਨਿਲਾਮੀ ਦੀ ਮਿਆਦ ਦੇ ਅੰਦਰ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

ਜੇਕਰ ਨਿਲਾਮੀ ਦੇ ਅੰਤ ਵਿੱਚ ਭਾਗੀਦਾਰ ਨੇ ਸਭ ਤੋਂ ਉੱਚੀ ਕੀਮਤ ਨਿਰਧਾਰਤ ਕੀਤੀ ਹੈ, ਤਾਂ ਉਹ ਨਿਰਧਾਰਤ ਕੀਮਤ ਅਤੇ ਮੁਦਰਾ ਜੋੜੇ 'ਤੇ ਸੰਬੰਧਿਤ ਲਾਟ ਲਈ ਭੁਗਤਾਨ ਕਰਨ ਲਈ ਇੱਕ ਐਕਸਚੇਂਜ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜ ਸਕਦਾ ਹੈ।

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)
}

ਬੀਮਾ / Crowdfunding

ਆਉ ਇੱਕ ਅਜਿਹੀ ਸਥਿਤੀ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਵਿੱਤੀ ਨੁਕਸਾਨ ਦੇ ਵਿਰੁੱਧ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੰਪੱਤੀ ਦਾ ਬੀਮਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਉਪਭੋਗਤਾ ਇੱਕ ਗਾਰੰਟੀ ਚਾਹੁੰਦਾ ਹੈ ਕਿ ਜੇਕਰ ਇੱਕ ਟੋਕਨ ਘਟਦਾ ਹੈ, ਤਾਂ ਉਹ ਇਹਨਾਂ ਟੋਕਨਾਂ ਲਈ ਅਦਾ ਕੀਤੀ ਪੂਰੀ ਰਕਮ ਵਾਪਸ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਹੋ ਜਾਵੇਗਾ, ਅਤੇ ਬੀਮੇ ਦੀ ਇੱਕ ਵਾਜਬ ਰਕਮ ਦਾ ਭੁਗਤਾਨ ਕਰਨ ਲਈ ਤਿਆਰ ਹੈ।

ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, "ਬੀਮਾ ਟੋਕਨ" ਜਾਰੀ ਕੀਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ। ਫਿਰ ਪਾਲਿਸੀਧਾਰਕ ਦੇ ਖਾਤੇ 'ਤੇ ਇੱਕ ਸਕ੍ਰਿਪਟ ਸਥਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਸਿਰਫ਼ ਉਹਨਾਂ ਐਕਸਚੇਂਜ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜੋ ਕੁਝ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਕਰਦੇ ਹਨ।

ਦੋਹਰੇ ਖਰਚੇ ਨੂੰ ਰੋਕਣ ਲਈ, ਤੁਹਾਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ (ਕੁੰਜੀ, ਮੁੱਲ) = (ਖਰੀਦਣ ਟਰਾਂਸੈਕਸ਼ਨ ਆਈਡੀ, ਸੇਲ ਆਰਡਰ ਆਈਡੀ) ਦੇ ਨਾਲ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਪਾਲਿਸੀਧਾਰਕ ਦੇ ਖਾਤੇ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਭੇਜਣ ਲਈ ਬੇਨਤੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਪਹਿਲਾਂ ਹੀ ਵਰਤੀ ਜਾ ਚੁੱਕੀ ਕੁੰਜੀ ਨਾਲ ਡੇਟਾ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਭੇਜਣ ਤੋਂ ਮਨ੍ਹਾ ਕਰੋ।

ਇਸ ਲਈ, ਉਪਭੋਗਤਾ ਦੇ ਸਬੂਤਾਂ ਵਿੱਚ ਬੀਮਾ ਟੋਕਨ ਦੀ ਖਰੀਦ ਦਾ ਲੈਣ-ਦੇਣ ID ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਮੁਦਰਾ ਜੋੜਾ ਖਰੀਦ ਲੈਣ-ਦੇਣ ਦੇ ਸਮਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਲਾਗਤ ਵੀ ਖਰੀਦ ਦੇ ਸਮੇਂ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਬਰਾਬਰ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ, ਬੀਮੇ ਦੀ ਕੀਮਤ ਘਟਾਓ।

ਇਹ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਬਾਅਦ ਵਿੱਚ ਬੀਮਾ ਖਾਤਾ ਉਪਭੋਗਤਾ ਤੋਂ ਬੀਮਾ ਟੋਕਨਾਂ ਨੂੰ ਉਸ ਕੀਮਤ ਤੋਂ ਘੱਟ ਕੀਮਤ 'ਤੇ ਖਰੀਦਦਾ ਹੈ ਜਿਸ 'ਤੇ ਉਸਨੇ ਉਨ੍ਹਾਂ ਨੂੰ ਖਰੀਦਿਆ ਸੀ: ਬੀਮਾ ਖਾਤਾ ਇੱਕ ਐਕਸਚੇਂਜ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ, ਉਪਭੋਗਤਾ ਆਰਡਰ 'ਤੇ ਹਸਤਾਖਰ ਕਰਦਾ ਹੈ (ਜੇਕਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਸਹੀ ਢੰਗ ਨਾਲ ਪੂਰਾ ਹੋਇਆ ਹੈ), ਬੀਮਾ ਖਾਤਾ ਦੂਜੇ ਆਰਡਰ ਅਤੇ ਪੂਰੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ 'ਤੇ ਦਸਤਖਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਬਲਾਕਚੈਨ ਨੂੰ ਭੇਜਦਾ ਹੈ।

ਜੇਕਰ ਕੋਈ ਖਰੀਦਦਾਰੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਉਪਭੋਗਤਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਦੱਸੇ ਗਏ ਨਿਯਮਾਂ ਦੇ ਅਨੁਸਾਰ ਇੱਕ ਐਕਸਚੇਂਜ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਬਣਾ ਸਕਦਾ ਹੈ ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਨੂੰ ਬਲਾਕਚੈਨ ਨੂੰ ਭੇਜ ਸਕਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਉਪਭੋਗਤਾ ਬੀਮਾਯੁਕਤ ਟੋਕਨਾਂ ਦੀ ਖਰੀਦ 'ਤੇ ਖਰਚ ਕੀਤੇ ਪੈਸੇ ਨੂੰ ਵਾਪਸ ਕਰ ਸਕਦਾ ਹੈ।

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 (ਜੋ ਤੁਹਾਡੇ ਤੋਂ 10 *N/taxDivisor WAVES 'ਤੇ ਖਰੀਦਿਆ ਜਾ ਸਕਦਾ ਹੈ) ਦੀ ਮਾਤਰਾ ਵਿੱਚ FeeCoin ਦੇਵੇਗਾ, ਅਤੇ ਤੁਸੀਂ ਮਾਈਨਰ ਨੂੰ N/taxDivisor WAVES ਦੇਵੋਗੇ। ਨਤੀਜੇ ਵਜੋਂ, ਤੁਹਾਡਾ ਮੁਨਾਫ਼ਾ (ਟੈਕਸ) 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