xpub | POSIX Shell script to get | Script Programming library

From official docs

Address derivation will default to bech32 (native SegWit) unless a different purpose is specified. For example: to derive wrapped SegWit addresses (starting with 3...) specify the appropriate purpose with purpose: Purpose.P2SH.

So, to get m44 you need to set purpose:Purpose.P2PKH

Sample

Q : "Is the solution that simple?"

The very contrary. For what was posted above, the solution is over-complicated w.r.t. the so far posted use-case requirements.

a) Given the requirements above, it is possible to eliminate all the costs associated with the setup & maintenance of the ISO-OSI-L3 tcp:// Transport Class, when communicating among threads co-located on the same host belonging to the same process. Rather go in for the ultra-fast, stack-less, memory-mapped inproc:// Transport Class to avoid all of these inefficiencies. ZeroMQ API v4.0+ have also the comfort of no other conditions on setting up the inproc://-TransportClass { .bind() | .connect() }-order of appearance, so we may enjoy the utmost MEM-mapped ultra-low latency flagging of Zero-Copy "transported" messages (without moving a byte of in-RAM data) - cool, isn't it? ( unless you need a MITM protocol-sniffing to be injected, remove the tcp:// overkill )

b) Given the requirements above, a delivery of a couple of messages, where the "static" SUB-side subscribes to all of them, is enormously inefficient use of the PUB/SUB Scalable Formal Communications Pattern Archetype. Your code has to pay all costs to setup a new SUB-instance, then it crawls to setup a valid connection (over the tcp://-TransportClass' stack, hopefully removed under a) ), next wrangling to setup a new TOPIC-filter (be it operated on the SUB-side in earlier versions or on the PUB-side in the newer ZeroMQ releases -- all at remarkable costs of doing so just to receive all messages -- i.e. no filtering at all). The same formal service is achievable with a way more lightweight many-nodes-PUSH/PULL-on-one-node. If there is no other need for any reverse / bi-directional / more complex formal communications, this just one PUSH/PULL will be able to do the job requested.

c) Given the requirements above, your accent seems to have been put on not losing messages by prematurely sending them over the connection. There are tools for ascertaining that in ZeroMQ settings, yet you take no care to use them:

• using zmq.IMMEDIATE may use the blocking state of an AccessNode in cases no ready-made connection is working yet (or ever)
• using return codes & errno ( or zmq.errno() for POSIX-incompatible operating systems / Win32 and likes ) handling may help your code to detect & to react to any and all specific situations that happen in "network-of-autonomous-agents" throughout the whole span of its lifecycle in the distributed-computing ( no matter if the agents are indeed actually "physically" distributed or co-located, as is the case here ). Not losing the control is the core responsibility here. What is a control-code, that self-locks in a lost-control state, where it cannot control even itself ;) ?

d) Never use a blocking form of the { .recv() | .send() | .poll() | ... }-methods. Schoolbook examples are rather anti-patterns of how a professional signaling/messaging metaplane implementation ought look like. Indeed never - ref. item 5) above.

e) Better re-use a Context()-instance, instead of making it a consumable/disposable as was sketched above. Threads can freely share a pre-instantiated Context()-engine, avoiding next huge amounts of repetitive add-on overhead costs, if re-instantiating a consumable/disposable Context() per each forked, just a short-lived, peer client thread.

f) If anybody knows a better solution, keep us posted :o)

a)
Subscriber will be on another machine, so I think tcp:// is the solution.*

Sure, NP here. { pgm:// | epgm:// | tipc:// }-transports might be interesting here if going further into higher performance levels direction

b)
Subscriber is going to forward via an XPUB socket the messages to other subscribers. PUSH/PULL could work but if I want to pass those subscriptions and their filters to the initial publishers and filter some messages at the source, I have to use PUB/SUB pattern.

Well, not mentioned in the O/P. Any layering of XPUBs/XSUBs may work well, the problems are on connection-management level

c)
Just to clarify, not losing messages is important only when there is a subscriber. Could you explain this part a little more?

Sure, having no subscriber available on an RTO-connected link, ready for an immediate delivery "across the wire", no messages could be ever delivered ( and could be silently dropped, which is what you try to fight against, don't you? ). That is what zmq.IMMEDIATE can manage via a call to a .setsockopt()-method.

A working async variant is

The Proxy routes published messages from upstream producer (PUB) to downstream consumer (SUB). It passes subscribe/unsubscribe messages from the consumer to the publisher. The publisher's PUB socket drops any messages for which there is no subscription.

So if there are no consumers downstream of the Proxy, and the Producer only publishes to the Proxy, all the producer's messages will be dropped by its PUB socket. Only after a consumer subscribes via the Proxy's XPUB (and the proxy, in turn, forwards the subscription to the producer via XSUB to PUB) will the messages actually be forwarded by the producer's PUB socket, through the proxy, to the consumer.

I'm not sure whether the proxy actively manages the passed-through subscriptions or simply passes them through and lets the producer's PUB socket handle it. I think it's the latter. The proxy does buffer the messages to allow for consumer (or producer) outage/reconnect.

Q : "... but am wondering if there is a zmq way of adding ... to each message ...?"

No, there is not. ZeroMQ way would be to have this done with Zero-Copy and _(almost) Zero-Latency.

Such way does not exist for your wished use-case.

Create a transforming-node, where each message will get transformed accordingly ( SEQ-number added and TimeSTAMP datum { pre | ap }-pended ). Such step requires one to implement such a node and handle all such steps altogether with any exceptions per incident.

The ready-made API-documented zmq_proxy() simply does not and cannot and should not cover these specific requirements, as it was designed for other purposes ( and uses a Zero-Copy for the most efficient pass-through + ev. efficient MITM-logger mode(s) of service ).

Q : Is it possible for a publisher to publish to multiple clients on the same machine using ZeroMQ?

Oh sure, it is. No doubts about that.

Check the code. The responsibility of the order-of-execution is there. In distributed-systems this always so.

Once the [Client]-No1 instance gets a plausible .readLine()-ed input it will jump-in:

Public-key. Mathematically an elliptic curve public key is a point on the curve. For the elliptic curve used by Bitcoin, secp256k1, as well as other X9-style (Weierstrass form) curves, there are (in practice) two standard representations originally established by X9.62 and reused by many others:

• uncompressed format: consists of one octet with value 0x04, followed by two blocks of size equal to the curve order size containing the (affine) X and Y coordinates. For secp256k1 this is 1+32x2 = 65 octets

• compressed format: consists of one octet with value 0x02 or 0x03 indicating the parity of the Y coordinate, followed by a block of size equal tot he curve order containing the X coordinate. For secp256k1 this is 1+32 = 33 octets

The public key output by your trezor is the second form, 0x02 + 32 octets = 33 octets. Not 32.

I've never seen an X9EC library (ECDSA and/or ECDH) that doesn't accept at least the standard uncompressed form, and usually both. It is conceivable your python library expects only the uncompressed form without the leading 0x04, but if so this gratuitous and rather risky nonstandardness, unless a very good explanation is provided in the doc or code, would make me suspicious of its quality. If you do need to convert the compressed form to uncompressed you must implement the curve equation, which for secp256k1 can be found in standard references, not to mention many implementations. Compute x^3 + a*x + b, take the square root in F_p, and choose either the positive or negative value that has the correct parity (agreeing with the leading byte here 0x02).

The 'xpub' is a base58check encoding of a hierarchical deterministic key, which is not just an EC(DSA) key but adds metadata for the key derivation process. If you base58 decode it and remove the check, you get (in hex):