That is the input

By the way, for proven the ownership of one UTXO locked by a p2pkh script you must: provide the public key and a valid signature for it. Then the coins are locked again in a new p2pkh, and until the owner sped it again the public key will be kept secret. That's why you shouldn't re-use addressees, the public key will be disclosed after the firs transaction.

I don't would to say "lack of intelligence", even we use numeric approximations for munch cases. Both computers and humans can't deal with big numbers without a "easy way" to do.


Bitcoin's pay-to-public-key-hash is a standard transaction that, in stead of recording the receiver public key in the blockchain, record only the ripdem160(sha256(pKey)). For spending it, one mus provide a key that it's hash is equal to the value in blockchain. The use of two different algorithms is made to reduce the chance of an attacker find the right hash using pre-image or some  attack to the hash. To broken a p2pkh you must broken both sha256 and ripdem160, as well find the right public key to create the pre-image (only a limited set o public keys on the whole space). Theoretically, if you find a good way to calculate the discrete log and use it to broke bitcoin keys, you will not go so far, because you don't know what public key look for (except for the very first transactions, and in case of key reuse)

What you mean to connect? Connect your c-lightning node as one peer, or make the two nodes act as one?

Sorry for the terms, I talk about it on my day-by-day and missuppose that everyone know it!

Discrete logarithm are logarithms function with discrete numbers (integers are discrete, for example)

Series are not more then a sum of simple terms with a former rule: like x+x²+x³+x⁴... is formed from sum (xⁿ) where sum() is just the sum of all terms.

Taylor Series are some special ones that gives the same (or close to) the result of another. For exemplo, how carry out in a CPU that only knows basic math (sum, subtract...) functions like sin(x). We use this Series to get the result, like this:
https://wikimedia.org/api/rest_v1/media/math/render/svg/3e8311bbbeac9364f73b437929aa85c71715a7a8


Yes! What is the log of 4 in base 2; two, of course. But, why? I know that 2² is 4, and I also know that the log ₂(4) is a number n, that when I take 2^a it returns 4. This method is called "imediate" or "intuitive", and works for small number. But for big numbers, the process becomes hard. Imagine hand-calculate log_12334434343(34234325654767454)? So, isn't mathematically impossible (there is methods to solve then) but is HARD.



Because taking the process on the "right" direction (private -> public) not involves DLs. Is basically ordinary math, but to go backwards you should solve a DL, hence this function is so called "an one way function". This is the point you should keep in mind (sorry if I'm being boring) in one way: ordinary math, in the other way: DLs.

G is just a convention, for the point where the calculations begins. There is some optimizations that can be done, but in general terms, every point on the curve can be a generator point. For computing a given public key, just take the secret and multiply it for G. Your result is the public key.
Elliptic curve cryptographic (or ECC) assumes that when you have a curve defined over a discreet set of numbers, is impossible to do the inverse operations (subtraction and division), because to do so, you need compute something called  a discrete logarithm(DL).
Your computer can calculate logarithm over the real numbers set because there is a serie, called Taylor Serie that is a numerical approximation of the result (i.e gives the sabe output to a given input). But this series are ONLY defined over real numbers, and without a method to compute it, the only way to solve is via brute force.
We use brute force methods for solve small logarithms or to factor small number, but for really big numbers, like 2¹²³, this method keeps useless. This makes the safety of ECC and RSA respectively.
And because it, we can easily calculate the public key via multiply (no DL here), but we can't make the inverse, find out the private key from the public (a DL need to be solved).

Maybe you can thought whether there is some way to solve DL. Yes, there is! But with digital computer and numbers in a big order (2²⁵⁶) it will take forever. (Pollard's Kangaroo is an example)

Because this operation isn't defined on elliptic curves, most specially in a curve defined over a discreet field, this leads to the "discreet logarithm problem" that are an unsolved problem so far.
if you are using a curve over, let's say, the real numbers set, you can calculate it. But for cripto, usually the curves are defined over a set mod(p).

secp256k1 is defined over the set mod(p), where p is:

You have way to compile the code? If yes, you can open the "init.cpp" file, and change the line 878 (Core-0.20.0)
from:
ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK | NODE_NETWORK_LIMITED);
to:
ServiceFlags nLocalServices = ServiceFlags(NODE_NETWORK_LIMITED);
But, you probably had seen in BIP159 that your node still will send the most recent blocks (the BIP says 288)

Edit: Newbie question, how add code in the wiki's markdown?

Blockstream already have a satellite network that work almost everywhere, you only need a dish and a open-source decoder to use. Also there are some companies that use the satellite technology and a Mesh network to connect to then.

The network have a certain degree of redundancy and decentralization, once you can have multiples antennas pointed to the satellite and everyone with access to the mesh network can connect to this nodes, maybe te only problem is the centralization of the satellite operation (only blockstrem, from exemple). If we have multiple satellites and multiples antennas in a large network, it may work!

Maybe I'm wrong, but if you change the node services for NETWORK_LIMITED(node send historical blocks), the peers will not request blocks to you. It's the only way that I know for you case.

Alguém aí quer fazer a Roberto Carlos coin, a criptomoeda que possui um bloco por ano, sempre no final do ano. O auge da escassez e reserva de valor!

I think that tor is a good choice so far. If your ISP keep hostile and start to filtering bitcoin protocol in its network, they can't stop the tor (if they block tor, you can use a bridge to connect to then). But I like Mesh network, probably in a local way this is even possible, creating a "cloud" that makes more difficult to track any specific transaction source, with a redoundant system of connections to others network (connecting to more than one network) may reduce the chance of attack. 
Also, I really think that the ISP is a real problem, since the data on bitcoin network are transmitted without encryption (correct me if I'm wrong), if a transaction comes out form your node without comes in previously, it can deduce that the transaction belong to you. This problem is also solved with tor.

Yes, you are right. Sorry! 
Re-using ephemeral keys are a problem only wen signing, not encrypting. Maybe they take it as a good practice?

As @AdolfinWolf said, when you encrypt any data with the Elliptic Curve Cripto Family, you create a random key called ephemeral key, and this key is used in the calculations AND ONLY ONCE, it is a disposable one. If this key is reused, is even possible to find your private key(and this already happened in the past). 

Like unstoppabledomains.com? They use the Ethereum's network to store the content, and deliver it through some gateways around the world. But, I personaly think that is no longer decentralized, once I don't have hardware to directly download the chain and retrieve my site(they chain is very big, if you download the whole data), I have to trust in third parties, like cloudfire. ZeroNet and similars are very better

You can try mount the server file system remotely on the others computes, but it probably will lead to a error because more than one instance of bitcoin is running (the core knows it because the .lock file). 
But if your node are already running, there is no reason to have more then one node running, just download a SPV, as you can see above(electrum are a good one), and connect it to your full node. You not will loose privacy in this case