[ENG/ITA] Earning HIVE Thanks to My Scripts: Bridges Arbitrage and Grid Trading


La versione italiana si trova sotto quella inglese

The italian version is under the english one


Earning HIVE Thanks to My Scripts: Bridges Arbitrage and Grid Trading

Programming, for me, is nothing more than a hobby.

I wish it weren't like that. I wish I were better at it and could work in the programming world, but the truth is I didn't follow the right studies, and I don't have the time now to pursue a completely different path from the one I've followed so far. A part of me would love to, but it would almost certainly be madness.

That's why my Python projects will always be amateurish, simple, and – in the eyes of a real programmer – probably ugly and poorly designed... but ultimately, if I'm coding just for fun, why should I care if what I create is little more than a toy?

And the answer is: I don’t. If the scripts I write do what I created them for, they entertain me, and give me small satisfactions, that’s good enough for me.

Also because lately, some of the projects I've worked on over the past months have shown me that you can achieve something even with little: I used to think that without great skills, abilities, and knowledge it was impossible to create something useful... but I was wrong.

And in this post, I’d like to focus on one topic in particular — one that, until not long ago, I thought was completely beyond my abilities — namely, earning money thanks to my scripts.

How can I earn anything if I just said I’ll never be able to get a job as a programmer because I don’t have the necessary skills?

Well, lately I discovered that, in some way, I can!


Bridging arbitrage

What proved to me that I could earn something thanks to my scripts is a project I already mentioned here, specifically the one about arbitraging the bridges that connect HIVE with SWAP.HIVE, taking advantage of the fact that, under certain conditions, it’s possible to generate a positive fee, thus making a profit.

The script I created uses all my liquid HIVE to perform operations of this type through the @liquid.wolf account: over the ~15 days this project has been running, I’ve made a profit of almost 200 HIVE, plus over 5.8 BXT – a token I talked about here.



initially @liquid.wolf had 1695 HIVE and 0 BXT available

This event, in a way, opened my eyes, because it showed me that even with basic knowledge like mine, it’s possible to create scripts that generate a profit.

A little voice in my head even started wondering: what if I managed to create dozens of scripts like this one?


Grid trading

And that brings us to the second project I wanted to talk about today, the one I’m developing based on an idea from @bencwarmer and inspired by what @hoosie used to do — namely, trying to take advantage of price fluctuations in HIVE to do something that, according to ChatGPT, is called grid trading.

def place_orders(account, nodes, session: requests.Session, diff, trades, amount, market, lowest, highest):
    for _ in range(trades):
        hive, hbd = get_balances(account, nodes, session)
        print(f"Balances available: {hive} HIVE and {hbd} HBD")

        if float(hbd) > amount:
            sell_price = round(highest + diff * highest / 100, 4)
            print("Looking to sell HBD...")

            sell = place_sell_order(
                account, sell_price, amount, market
            )  # Buy HIVE, sell HBD
            time.sleep(3)

        if float(hive) > amount * lowest:
            buy_price = round(lowest - diff * lowest / 100, 4)
            print("Looking to sell HIVE...")

            buy = place_buy_order(
                account, buy_price, amount, market
            )  # Sell HIVE, buy HBD
            time.sleep(3)

        diff += 1

a snippet of the code

The idea is to convert HIVE into HBD when the price goes up, and HBD into HIVE when the price drops, using very small increments/decrements and canceling older orders when they become too far from the current price.

This script is also already active, although not fully yet, because I’m still fine-tuning it and currently launch it manually when I want to run tests.

I still need to implement, for example, a system to keep track of completed operations, so I can automatically calculate whether the script is generating a profit or not.

In this project, the goal isn’t so much to find a second way to earn right now, but to improve my skills in trading: if I manage to create a solid, reliable, and functional script, I could then look for simpler opportunities to apply what I’ve learned and see if I can generate another small passive income.

There’s a 99% chance I’ll never work as a programmer — but who knows, maybe one day my own scripts will work for me :)


cover made with Bing AI and edited with GIMP

to support the #OliodiBalena community, @balaenoptera is 3% beneficiary of this post


If you've read this far, thank you! If you want to leave an upvote, a reblog, a follow, a comment... well, any sign of life is really much appreciated!


Versione italiana

Italian version


Guadagnare HIVE Grazie ai miei Scripts: Arbitraggio dei Bridges e Grid Trading

Programmare per me è niente più che un hobby.

Vorrei che non fosse così, vorrei essere più bravo e poter lavorare nel mondo della programmazione, ma la verità è che non ho fatto gli studi giusti e non ho il tempo per provare adesso ad inseguire una strada completamente diversa da quella che ho percorso finora. Una parte di me vorrebbe, ma sarebbe quasi sicuramente una follia.

Per questo i miei lavori in Python saranno sempre amatoriali, semplici e - agli occhi di un vero programmatore - pure brutti e poco funzionali... ma tutto sommato, se devo programmare solo per divertimento, alla fine cosa mi importa se ciò che creo è poco più di un gioco?

E' la risposta infatti è "nulla". Se gli script che scrivo fanno ciò per cui li ho creati, mi fanno divertire e mi danno delle piccole soddisfazioni, a me sta bene.

Anche perchè ultimamente alcuni dei progetti a cui ho lavorato in questi mesi mi hanno dimostrato che anche con poco si può ottenere qualcosa: pensavo che senza aver grandi capacità, abilità e conoscenze fosse impossibile creare qualcosa di utile... ma mi sbagliavo.

E in questo post vorrei focalizzarmi su un argomento in particolare, uno che di base, per quello che pensavo fino a poco tempo, sarebbe dovuto essere completamente al di là delle mie capacità, ossia guadagnare grazie ai miei scripts.

Come posso infatti guadagnare se ho detto sopra che non potrò mai trovare un lavoro come programmatore, dato che non ho le necessarie competenze?

Be', in quest'ultimo periodo ho scoperto che, in qualche modo, posso!


Arbitrare i bridges

Ciò che mi ha dimostrato che posso guadagnare qualcosa grazie ai miei scripts è un progetto di cui vi avevo già parlato qua, ed in particolare quello che riguarda la possibilità di arbitrare i bridges che collegano HIVE con SWAP.HIVE, sfruttando il fatto che, in determinate condizioni, sia possibile generare una commissione positiva, ottenendo così un guadagno.

Lo script che ho creato utilizza tutti i miei HIVE liquidi per compiere operazioni di questo tipo tramite l'account @liquid.wolf: nei circa 15 giorni di attività di questo progetto ho ottenuto un guadagno di quasi 200 HIVE, oltre 5.8 BXT - un token di cui vi ho parlato qua.



inizialmente @lqiuid.wolf aveva disponibili 1695 HIVE e 0 BXT

Si tratta di un evento che, in un certo senso, mi ha aperto gli occhi, perchè mi ha dimostrato che, anche con conoscenze basiche come le mie, è possibile creare degli scripts che possano generare un guadagno.

Una piccola vocina nella testa ha anche cominciato a chiedersi: e se riuscissi a creare decine di script come questo?


Grid trading

E passiamo così al secondo progetto di cui volevo parlarvi oggi, quello che sto sviluppando sulla base di un'idea di @bencwarmer ed ispirandomi a quello che faceva un tempo @hoosie, ossia cercare di sfruttare le oscillazioni nel prezzo di HIVE per fare una cosa che, secondo ChatGPT, si chiama grid trading.

def place_orders(account, nodes, session: requests.Session, diff, trades, amount, market, lowest, highest):
    for _ in range(trades):
        hive, hbd = get_balances(account, nodes, session)
        print(f"Balances available: {hive} HIVE and {hbd} HBD")

        if float(hbd) > amount:
            sell_price = round(highest + diff * highest / 100, 4)
            print("Looking to sell HBD...")

            sell = place_sell_order(
                account, sell_price, amount, market
            )  # Buy HIVE, sell HBD
            time.sleep(3)

        if float(hive) > amount * lowest:
            buy_price = round(lowest - diff * lowest / 100, 4)
            print("Looking to sell HIVE...")

            buy = place_buy_order(
                account, buy_price, amount, market
            )  # Sell HIVE, buy HBD
            time.sleep(3)

        diff += 1

un estratto del codice

L'idea sarebbe quella di convertire HIVE in HBD quando il prezzo sale e HBD in HIVE quando il prezzo scende, prevedendo incrementi/decrementi molto piccoli e cancellando gli ordini più vecchi quando cominciano ad essere troppo lontani dal prezzo attuale.

Anche questo script è già operativo, anche se ancora non completamente, perchè lo sto rifinendo e per ora lo lancio quando voglio fare dei test.

Devo ad esempio ancora implementare un sistema che tenga traccia delle operazioni completate, così da poter calcolare in automatico se lo script sta generando un guadagno o meno.

Nel caso di questo progetto la speranza non è tanto quello di trovare di già un secondo modo per guadagnare, quanto quella di affinare le mie capacità nell'ambito del trading: se riuscirò a creare uno script solido, affidabile e funzionante, potrei infatti poi cercare occasioni più semplici da sfruttare per mettere in pratica quanto imparato e vedere se riesco a generare un'altra piccola rendita passiva.

Al 99% non lavorerò mai come programmatore, ma chissà che un giorno non possano essere i miei stessi scripts a lavorare per me :)


cover realizzata con Bing AI ed editata con GIMP

a supporto della community #OliodiBalena, il 3% delle ricompense di questo post va a @balaenoptera

Se sei arrivato a leggere fin qui, grazie! Se hai voglia di lasciare un upvote, un reblog, un follow, un commento... be', un qualsiasi segnale di vita, in realtà, è molto apprezzato!

Posted Using INLEO



0
0
0.000
55 comments
avatar

E lo script che dà i numeri vincenti del SuperEnalotto? 😜

!LOLZ

Sempre all'opera!!! Complimenti!!! 💪🏻

0
0
0.000
avatar

Ammazza, sei bravo. Noi l'anno scorso abbiamo investito in un robottino che faceva la stessa cosa ma sfruttando le piccole oscillazioni euro dollaro. Ci ha dato una piccola soddisfazione. Poi purtroppo il progetto si è concluso.
@barnabo73 leggi qua, è molto interessante
!LOLZ

0
0
0.000
avatar

Magari fossi bravo! Diciamo che ci acchiappo qualcosa e almeno riesco a togliermi la soddisfazione di vedere qualcuno dei miei progetti funzionare, ogni tanto 🤣

sfruttando le piccole oscillazioni euro dollaro

Se questo script funzionasse e si dimostrasse affidabile, la coppia euro-dollaro sarebbe sicuramente molto interessante da esplorare, visto che tende ad avere un rapporto stabile per periodi prolungati di tempo. Peccato solo che in ambito crypto ci siano pochissime stablecoins ancorate all'euro, per cui probabilmente avrei qualche difficoltà nel farlo (mentre al di fuori dell'ambito delle crypto non saprei nemmeno da dove iniziare... !LOL).

0
0
0.000
avatar

Temo di averti scatenato Barnabo. Perdonami!!! Sta infoiato con Pyton!
!LOLZ

0
0
0.000
avatar

Nessun problema, anzi, come ho detto a lui io sono stracontento se qualcuno vuole parlare di Python! Confrontarsi è uno dei modi migliori per imparare... ed io ne ho un disperato bisogno 🤣

!LOL

0
0
0.000
avatar

You'd be surprised how many people go to uni for this shit, finish, and can not do what you are doing now.

I takes a certain kind of thinking to start from scratch and build a program. Most people could not do it.

Additionally, it takes focus.
People who struggle to focus on single problems, or to sit down to think, can't do it either. I think this is the main ability: sit down to code for a long time.

Thinking you are behind the curve because you don't know some algorithms and theory... In times of AI? You'd catch up within 1 year.

That all being said, programming as a career is ass.

0
0
0.000
avatar

Solving problems and focusing to find a solution is what makes me love programing! I love thinking on how I can solve, or improve, something: for me the challenge of finding a solution, trying to think outside the box, is the most satisfying part of programing.

Thinking you are behind the curve because you don't know some algorithms and theory

And talking about that, recently I was planning to give a (re)read at some of your posts, to see if I have acquired some of the skills need to better understand them :)

That all being said, programming as a career is ass.

My issue is that I already to a job which I don't like... so I can't help but ask myself how would be to do something different... and at least programing looks as something I may like doing even as a job (even if this might not be true, lol, as I have only a very vague idea on what a programer do!).

0
0
0.000
avatar

And talking about that, recently I was planning to give a (re)read at some of your posts, to see if I have acquired some of the skills need to better understand them :)

Could be my fault.

If you continue the Python path and try building more things for web, the shit I wrote will make sense (I hope).
Have you encountered callback functions, yet?
It's that but... for real Gs.
I guess I jumped a few steps too far ahead...

0
0
0.000
avatar

If you continue the Python path and try building more things for web, the shit I wrote will make sense (I hope).

I'm sure it will! :) I'm progressing slowly, but sooner than later it will all make sense, I'm sure of that!

Have you encountered callback functions, yet?

Nope, not yet! I just checked what they are to be sure. More stuff to learn 🤣

0
0
0.000
avatar

I think you are doing fine.
When you need callbacks, you'll then figure it out.

keep track of completed operations, so I can automatically calculate whether the script is generating a profit or not.

easiest solution: write to .txt or .log file.

with open('somefile.txt', 'a') as the_file:
    the_file.write('Hello\n')

better: .csv file

even better (overkill rn): SQLite (or any other DB)
...this is where my posts kick in.
When you want the thing as a service and have n customers, it's getting ridiculous and problematic to have n files.

0
0
0.000
avatar

better: .csv file

I was thinking at this one, even if I'm tempted to explore SQLite, even if it's clearly too much for what I need... but it might be a good opportunity to learn something new :)

0
0
0.000
avatar
with open

Is cool Python stuff. That's enough concept to work on.

btw, your script: what happens if there is a huge swing in the market?
say, all your liquidity is on the HBD side, and the HIVE price hikes 100% and stays up... (happened to me kind of 🤣)

0
0
0.000
avatar

I'd be f*cked 🤣 !LOL

jokes aside, I'm keeping most of my liquid HIVE away from this project, so I'm playing only with a small amount of HIVE and HBD.

And if the price pumps (or dumps) the script deletes the orders which are too far from the new price range and place new orders (but I would have to inject new liquidity for the side which has been depleted the spike). Surely it would be a bad scenario, if it happened too often.

0
0
0.000
avatar

I really love video games where you go for an deep sea adventuring.
They're just so immersive.

Credit: reddit
@felixxx, I sent you an $LOLZ on behalf of arc7icwolf

(6/10)
Delegate Hive Tokens to Farm $LOLZ and earn 110% Rewards. Learn more.

0
0
0.000
avatar

200 Hive in 15 giorni! Wow, mica male! Complimenti!

0
0
0.000
avatar

Probabilmente il rilascio di Conclave Arcana ha inciso parecchio, perchè c'erano grossi spostamenti di denaro da Hive ad Hive-Engine e viceversa: mi aspetto un calo da ora in poi... anche se vorrei tanto sbagliarmi ed aver trovato una piccola miniera d'oro 🤣

0
0
0.000
avatar

Fidati che non vuoi fare il programmatore 😂 rotture di palle sabato e domenica, reperibilità, interventi serali perché è URGENTE e devi sempre essere pronto a dare supporto, trasferte in giro... Meglio l'amministrativo, poi non so che lavoro fai attualmente tu

Comunque 200 hive in 2 settimane mi sembra ottimo, meglio che fare post 😅

0
0
0.000
avatar

Probabilmente infatti io mi immagino il lavoro del programmatore in modo sbagliato 🤣 è che l'idea di lavorare in smart working per una società straniera sembra così allettante, soprattutto rispetto al passare le giornate chiuso in un ufficio dalle 9 alle 19... poi più che altro io faccio un lavoro che non mi appassiona, per cui mi piace sognare come sarebbe farne uno che mi piace (anche se non è detto mi piacerebbe, perchè un conto è programmare per divertimento, un conto farlo per lavoro, con scadenze e richieste imposte da altri).

Comunque 200 hive in 2 settimane mi sembra ottimo, meglio che fare post 😅

Credo che la presale e l'inizio della generale sale di Conclave Arcana possano avere inciso sui volumi di scambio di queste ultime settimane: mi aspetto che i guadagni non siano così alti in futuro (anche se sarei felice di sbagliarmi ahaahah).

0
0
0.000
avatar

Haha eh ma poi con le grandi aziende anche straniere hai le scadenze da rispettare, ti tocca fare straordinari e lavorare sempre extra orario... Ti dirò, a me fa schifo il mio lavoro da programmatore ma ormai è così 😂 i soldi devono arrivare da qualche parte alla fine

0
0
0.000
avatar
(Edited)

Come minimo infatti alla fine non mi piacerebbe nemmeno quello, hai ragione 🤣 e niente, bisogna avere la botta di culo di diventare ricchi (va be', benestanti già sarebbe sufficiente !LOL) così poi uno lavora per sè stesso, fa quello che gli piace e se guadagna bene, altrimenti amen.

0
0
0.000
avatar
(Edited)

o nasci figlio di imprenditori e vai ancora meglio 🤣 come il figlio del capo da noi che non fa una mazza tutto il giorno se non stare fuori in pausa e prende 3-4k al mese

0
0
0.000
avatar

Congratulations @arc7icwolf! You have completed the following achievement on the Hive blockchain And have been rewarded with New badge(s)

You got more than 24000 replies.
Your next target is to reach 24500 replies.

You can view your badges on your board and compare yourself to others in the Ranking
If you no longer want to receive notifications, reply to this comment with the word STOP

0
0
0.000
avatar

Interessante, grazie!
Lo script immagino tu lo faccia girare su un computer locale... Mac o Windows?
hai per caso il codice di get_balances(account, nodes, session)?
E.... come conservi le chiavi di accesso?
Grazie

0
0
0.000
avatar

get_balances è una funzione delle api di hive, se non erro...

0
0
0.000
avatar

Uso Windows, principalmente perchè ho sempre e solo usato quello, per cui se uno mi mette davanti un computer con Mac o Linux vado in tilt 🤣

Quando, e se, arriverò alla fase in cui lo script dovrà operare autonomamente, allora utilizzerò Github Actions per hostarlo, in modo non dover tenere una (mia) macchina sempre accesa.

come conservi le chiavi di accesso?

Per ora sono hardocoded nel codice (in barba a qualsiasi best practice in materia di sicurezza), ma appena lo renderò operativo ed autonomo utilizzerò la funzione "Secrets" di Github, che funziona in maniera simile (per il poco che ci capisco) all'utilizzo di un file .env.

hai per caso il codice di get_balances(account, nodes, session)?

Eccolo qua, con sotto anche get_response, che è la funzione che si interfaccia con le API di Hive:

def get_balances(account, nodes, session: requests.Session):
    data = (
        f'{{"jsonrpc":"2.0", "method":"condenser_api.get_accounts", '
        f'"params":[["{account}"]], "id":1}}'
    )
    result = get_response(data, nodes, session)
    return result[0]["balance"].split()[0], result[0]["hbd_balance"].split()[0]
def get_response(data, nodes, session: requests.Session):
    for node in nodes:
        response = session.post(node, data=data)

        if response.status_code == 502:
            continue

        result = response.json().get("result", [])

        if result or result == []:
            return result

        print(f"Error: Status Code: {response.status_code}")

get_balances è una funzione delle api di hive, se non erro...

Se c'era mi è sfuggita: nel mio codice io ho utilizzato get_accounts dell'API Condenser, che contiene varie informazioni sull'account selezionato, incluso l'ammontare di HIVE e HBD che possiede.

get_balances nel mio script è quindi solo una funzione personalizzata creata da me per costruire la prima parte della richiesta.

0
0
0.000
avatar

grazie mille!

Ancora una domanda, scusa...
Il codice seguente, se ho capito bene, crea un ordine di vendita di Hive al prezzo sell_price.

sell_price = round(highest + diff * highest / 100, 4)
place_sell_order(account, sell_price, amount, market)

Se il prezzo dell'hive è più basso round(highest + diff * highest / 100, 4), viene chiamata lo stesso la funzione 'place_sell_order', ma l'ordine non viene eseguito, mentre se l'hive è maggiore di round(highest + diff * highest / 100, 4), l'ordine viene eseguito e gli hive vengono venduti (cioè convertiti in Hbd).

Ho capito bene la logica?

Grazie!

0
0
0.000
avatar

Figurati! Non sai quanto mi fa piacere ricevere domande e confrontarmi con qualcuno su questi argomenti :) mi aiuta ad imparare!

Il codice seguente, se ho capito bene, crea un ordine di vendita di Hive al prezzo sell_price.

Sì, anche se, per essere più precisi, la parte a cui ti riferisci si occupa di vendere HBD al prezzo sell_price

        if float(hbd) > amount:
            sell_price = round(highest + diff * highest / 100, 4)
            print("Looking to sell HBD...")

            sell = place_sell_order(
                account, sell_price, amount, market
            )  # Buy HIVE, sell HBD
            time.sleep(3)

Mentre la parte che vende Hive (al prezzo buy_price) è quella dopo:

        if float(hive) > amount * lowest:
            buy_price = round(lowest - diff * lowest / 100, 4)
            print("Looking to sell HIVE...")

            buy = place_buy_order(
                account, buy_price, amount, market
            )  # Sell HIVE, buy HBD
            time.sleep(3)

Se il prezzo dell'hive è più basso round(highest + diff * highest / 100, 4), viene chiamata lo stesso la funzione 'place_sell_order', ma l'ordine non viene eseguito, mentre se l'hive è maggiore di round(highest + diff * highest / 100, 4), l'ordine viene eseguito e gli hive vengono venduti (cioè convertiti in Hbd).

Qui è un po' diverso perchè la condizione che innesca la creazione o meno di un ordine è questa (nel caso di vendita di HIVE, ad esempio):

        if float(hive) > amount * lowest:

Quindi, se il mio balance (float(hive) è maggiore dell'ammontare che intendo vendere (amount * lowest), allora lo script procede con la parte successiva e crea l'ordine.

Se invece il mio balance è uguale o minore, allora l'ordine non viene creato e si passa alla successiva iterazione del for loop.

Questa parte qui invece si occupa di determinare il prezzo di vendita (sempre di HIVE in questo caso):

buy_price = round(lowest - diff * lowest / 100, 4)

Per cui la logica è: verifico se ho balance sufficiente per creare un ordine con l'importo che ho scelto; se ce l'ho, calcolo il prezzo a cui voglio vendere e creo l'ordine chiamando la funzione place_buy_order(account, buy_price, amount, market) o place_sell_order(account, buy_price, amount, market) (che sono due funzioni della libreria beem).

Spero di essere stato chiaro, perchè il mio codice di sicuro non lo è 🤣

0
0
0.000
avatar

Grazie mille, ma devo rifletterci perchè non mi è chiaro.
Intanto partiamo dalle base, ti chiedo: lowest e highest cosa sono? Variabili dinamiche o cablate? Il prezzo più basso e più alto dell'hive?

0
0
0.000
avatar

Sono variabili dinamiche, rispettivamente l'offerta di vendita più bassa e di acquisto più alta presenti sul mercato.

0
0
0.000
avatar

in che periodo?

0
0
0.000
avatar

Ogni volta che lo script viene lanciato interrogo le API di Hive per ottenere il prezzo attuale; poi durante l'esecuzione dello script il prezzo non viene riaggiornato (anche se nel caso di esecuzione di più ordini potrei voler riaggiornare costantemente il prezzo, così da assicurarmi di star piazzando le offerte di vendita/acquisto con prezzi coerenti con quelli di mercato). Per ora lo aggiorno solo all'inizio perchè nella fase di test piazzo al massimo 3 ordini di vendita e 3 di acquisto, quindi il tutto si conclude in meno di 20 secondi.

0
0
0.000
avatar

A proposito di: if float(hive) > amount * lowest:
(vend hive per comprare hbd)

amount è la quantità di hbd (supponiamo 10) che voglio comprare. Supponiamo che 1 hbd valga 3.8 hive. quindi 10 * 3.8 = 38 hive. Devo avere almeno 38 hive per comprare 10 hbd. Ovviamente vendo gli hive quando il prezzo degli hbd è minore (lowest). Lowest per cui è conveniente comprare hbd. lowest è cablato o dinamico?

0
0
0.000
avatar

amount è la quantità di hbd (supponiamo 10) che voglio comprare. Supponiamo che 1 hbd valga 3.8 hive. quindi 10 * 3.8 = 38 hive. Devo avere almeno 38 hive per comprare 10 hbd

Tutto esatto; da qui poi vendo HIVE quando il prezzo di HIVE sale, e precisamente quando supera di una certa percentuale (che decido io al momento della creazione dell'ordine) l'offerta di vendita più bassa (lowest).

Quindi, continuando il tuo esempio, ho 38 HIVE che valgono 10 HBD e piazzo l'ordine di vendita con place_buy_order(account, buy_price, amount, market) impostando come prezzo 3.8 HIVE - (1 * 3.8 / 100), se vogliamo sfruttare un aumento del prezzo di HIVE rispetto ad HBD dell'1%.

Questa parte mentre lavoravo mi ha confuso un sacco perchè beem e le api di Hive in alcuni casi valutano i prezzi in HBD ed in altri in HIVE, per cui anche nello script ho dovuto tenerne conto.

0
0
0.000
avatar

Ok, grazie! Inizia ad essere più chiaro, nonostante io sia ancora ignorante su molti dettagli. Ad esempio, tu imposti il prezzo di vendita, ma se il prezzo di vendita reale non coincide, cosa succede? Succede che l'ordine rimane in stand-by? Parte non appena il prezzo di vendita coincide?... Grazie

0
0
0.000
avatar

Esattamente! In realtà è proprio quella l'idea dietro il grid trading: piazzo ordini di vendita incrementalmente più alti del prezzo di vendita attuale, così se il prezzo di HIVE sale, lo converto via via in HBD, sfruttando questa "oscillazione" verso l'alto. Idem, per gli ordini di acquisto, in cui vendo HBD per HIVE: piazzo ordini in attesa che il prezzo di HIVE cali dell'1%, 2%, 3%, etc, così posso trarre vantaggio di un'oscillazione verso il basso.

Quindi questo grid trading funziona bene se HIVE tende a restare stabilmente su un certo prezzo, aumentando ed diminuendo di valore poco ma spesso. Se poi il prezzo aumenta o diminuisce troppo, il mio script cancella gli ordini che ormai sono fuori range e ne piazza di nuovi leggermente sopra e sotto il nuovo valore.

Teoricamente, perciò, dovrebbe essere possibile ottenere un guadagno se si riescono a cogliere abbastanza oscillazioni di prezzo all'interno di un certo range, prima che il prezzo si sposti in un nuovo range.

In pratica, probabilmente alla fine sarà solo un esercizio dove avrò imparato qualcosa (si spera!) 🤣

0
0
0.000
avatar

Ciao! Ho provato a lanciare questo script con python, in effetti mi ha creato l'ordine (ho cercato di vendere un hive a 0.22 hbd, se ho capito bene), ma non è successo niente... Ho provato anche con prezzi maggiori, ma niente. Secondo te lo script è giusto? Se l'ordine non è accettato entro quanto tempo scade? Grazie!

from beem import Hive
from beem.account import Account
from beembase.operations import Custom_json
import json

Dati utente

username = "barnabo73"
active_key = "myactivekey" # tua chiave privata

Inizializza blockchain

hive = Hive(keys=[active_key])
account = Account(username, blockchain_instance=hive)

Parametri ordine

quantity = "1.00000"
price = "0.22"
symbol = "SWAP.HIVE" # Hive su Hive-Engine
order_type = "sell"

json_data = {
"contractName": "market",
"contractAction": "sell",
"contractPayload": {
"symbol": symbol,
"quantity": quantity,
"price": price
}
}

Prepara e firma la transazione JSON

tx = Custom_json(
**{
"required_auths": [username],
"required_posting_auths": [],
"id": "ssc-mainnet-hive",
"json": json.dumps(json_data)
}
)

Invia la transazione

broadcast_result = hive.finalizeOp(tx, username, "active")

print("Ordine piazzato:")
print(broadcast_result)

0
0
0.000
avatar

Appena posso controllo meglio, però intanto vedo che stai interagendo con Hive-Engine, per cui sicuramente il funzionamento sarà un po' diverso da Hive (magari non c'è tutto quel casino sul valore dell'operazione che una volta è in HIVE e l'altra in HBD 🤣).

0
0
0.000
avatar

Ecco, ora dovrebbe andare.

Mancava "type": "custom_json_operation", quando veniva creato il custom_json.

from beem import Hive
from beem.account import Account
from beembase.operations import Custom_json
import json
# Dati utente

username = "xxxx"
active_key = "xxxxx" # tua chiave privata

# Inizializza blockchain
hive = Hive(keys=[active_key])
account = Account(username, blockchain_instance=hive)

# Parametri ordine
quantity = "1.00000"
price = "1"
symbol = "SWAP.HIVE" # Hive su Hive-Engine
order_type = "sell"

json_data = {
    "contractName": "market",
    "contractAction": order_type,
    "contractPayload": {
        "symbol": symbol,
        "quantity": quantity,
        "price": price
    }
}

# Prepara e firma la transazione JSON
tx = Custom_json(
    **{
    "type": "custom_json_operation", # <--- mancava questo
    "required_auths": [username],
    "required_posting_auths": [],
    "id": "ssc-mainnet-hive",
    "json": json.dumps(json_data)
    }
)

# Invia la transazione
broadcast_result = hive.finalizeOp(tx, username, "active")

print("Ordine piazzato:")
print(broadcast_result)

Ho fatto due test con un altro token (perchè non avevo SWAP.HIVE a disposizione) e mi ha creato gli ordini :)

orders.JPG

0
0
0.000
avatar

grazie mille! Ho riprovato con la correzione, ma non capisco come capire se l'ordine è andato a buon fine...

0
0
0.000
avatar

Puoi controllare su questo block explorer:

https://he.dtools.dev/@barnabo73

Vedo però che non hai SWAP.HIVE disponibili, per cui se stai provando a creare ordini per questo token la transazione non andrà a buon fine!

0
0
0.000
avatar

scusa ancora la mia somme ignoranza, ma cosa sono gli swap.hive? Se intendi hive disponibili, ne ho molti....

0
0
0.000
avatar

SWAP.HIVE è l'equivalente di HIVE ma su Hive-Engine, per cui è proprio un token diverso, per quanto di valore identico ad HIVE.

Nel tuo wallet su Hive-Engine vedo che non ci sono SWAP.HIVE:

Per vedere se il tuo script funziona potresti cambiare il token symbol con WAIV, lanciare il tuo script e poi controllare su un block explorer o tramite lo script che hai inserito nell'altro commento se l'ordine così è stato recepito dalla blockchain (di base stavolta dovrebbe perchè hai disponibili parecchi WAIV).

Entrambi gli script che hai condiviso nei commenti sono infatti relativi ad Hive-Engine, non Hive, per cui è al primo che devi fare riferimento per vedere se hai abbastanza token per creare un ordine.

Per creare qualcosa che funzioni su Hive (invece che Hive-Engine) dovresti fare riferimento alla documentazione di beem ed a quella sulle API di Hive.

Se ti serve qualche esempio concreto dimmi pure :) nelle mie repositories su Github trovi alcuni esempi, anche se quelli più interessanti sono in repo private (perchè dentro ci copio spesso le mie chiavi private, evviva la sicurezza 🤣), ma posso inviarti in qualche modo anche quelli se ti possono fare comodo.

0
0
0.000
avatar

ah, ok! Beem invece usa i token direttamente su hive, se ho capito bene. Grazie mille, quando ho tempo ci studio un po'! I tuoi commenti sono molto preziosi, come vedi sono molto ignorante su molti aspetti base della blockchain, c'è molto da studiare...

0
0
0.000
avatar

Dipende, beem può essere utilizzata sia per Hive che per Hive-Engine, in alcune sue parti; ciò che fa la differenza sono:

  • i nodi a cui ti connetti (https://api.hive-engine.com/rpc/contracts ad esempio è un nodo di Hive-Engine)
  • come costruisci l'informazione che vuoi inviare (l'utilizzo del "payload" e di un "custom_json" ad esempio è tipico di Hive-Engine)

Esempi di nodi di Hive sono invece questi:

urls = [
        "https://api.deathwing.me",
        "https://api.hive.blog",
        "https://hive-api.arcange.eu",
        "https://hive.roelandp.nl",
        "https://api.openhive.network",
        "https://api.c0ff33a.uk",
        "https://anyx.io",
        "https://techcoderx.com",
        "https://rpc.mahdiyari.info",
    ]

Mentre un esempio di costruzione di un trasferimento, sempre per Hive, è questo:

def transfer_hive(sender, receiver="arc7icwolf", amount="0.001", memo=""):
    data = Transfer(
        **{"from": sender, "to": receiver, "amount": f"{amount} HIVE", "memo": memo}
    )
    
    hive = connect_to_hive()
    tx = TransactionBuilder(hive_instance=hive)
    tx.appendOps(data)
    tx.appendWif(PRIVATE_KEY)
    tx.sign()
    tx_id = tx.broadcast()
    print(tx_id)

La parte finale la potresti anche sostituire con hive.finalizeOps() che ti ho visto usare nel primo script che hai condiviso, dato che quello si occupa di inviare e firmare la transazione.

sono molto ignorante su molti aspetti base della blockchain, c'è molto da studiare...

Tranquillo, siamo sulla stessa barca 🤣

0
0
0.000
avatar

ho usato questo codice per vedere gli ordini attivi, ma brancolo un po' nel buio... Mi dice 'Nessun ordine attivo trovato....' eppure quando ho lanciato il tuo script corretto mi ha dato 'ordine piazzato'. Grazie ancora!

import requests

username = "myusername"

url = "https://api.hive-engine.com/rpc/contracts"
payload = {
"jsonrpc": "2.0",
"id": 1,
"method": "find",
"params": {
"contract": "market",
"table": "openOrders",
"query": {
"account": username
},
"limit": 1000
}
}

response = requests.post(url, json=payload)
orders = response.json().get("result", [])

print(f"Ordini attivi per {username}:")
if orders is None:
print("Nessun ordine attivo trovato o risposta non valida.")
else:
for order in orders:
print(order)

0
0
0.000