Saravanan666/pypi-org huggingface dataset:
Package: chiabip158
Chia BIP158This implements the compact block filter construction in BIP 158. The code is
not used anywhere in the Bitcoin Core code base yet. The next step towards
BIP 157 support would be to create an indexing module similar to TxIndex that
constructs the basic and extended filters for each validated block.Installpython3-mvenvvenv
.venv/bin/activate
pip3install.Run python testspython3tests/simple_test.pyInstallation steps on a fresh OSX imageInstall brew:ruby-e"$(curl-fsSLhttps://raw.githubusercontent.com/Homebrew/install/master/install)"brewinstallpython3brewinstallboostAt this point the only error is can’t find boost_thread libThe issue is the homebrew boost ships libboost_thread-mt libs but doesn’t
include plain libboost_thread, so clang can’t find it. Interestingly, homebrew
boost does have both plain and -mt files for the libboost_system libraries.$find/usr/local/lib/|grepboost_threadlibboost_thread-mt.alibboost_thread-mt.dylibSolution, with no guarantees that this is "the Right Way to do things", but
appears to work fine for the configure stage:cd/usr/local/libln-slibboost_thread-mt.alibboost_thread.aln-slibboost_thread-mt.dyliblibboost_thread.dylibci BuildingThe primary build process for this repository is to use GitHub Actions to
build binary wheels for MacOS, Linux (x64 and aarch64), and Windows and publish
them with a source wheel on PyPi. See.github/workflows/build.yml. CMake usesFetchContentto downloadpybind11. Building is then
managed bycibuildwheel. Further
installation is then available viapip install chiabip158e.g.Contributing and workflowContributions are welcome and more details are available in chia-blockchain'sCONTRIBUTING.md.The master branch is usually the currently released latest version on PyPI.
Note that at times chiabip158 will be ahead of the release version that
chia-blockchain requires in it's master/release version in preparation for a
new chia-blockchain release. Please branch or fork master and then create a
pull request to the master branch. Linear merging is enforced on master and
merging requires a completed review. PRs will kick off a GitHub actions ci
build and analysis of chiabip158 atlgtm.com.
Please make sure your build is passing and that it does not increase alerts
at lgtm.
Package: chia-blockchain
chia-blockchainChia is a modern cryptocurrency built from scratch, designed to be efficient, decentralized, and secure. Here are some of the features and benefits:Proof of space and timebased consensus which allows anyone to farm with commodity hardwareVery easy to use full node and farmer GUI and cli (thousands of nodes active on mainnet)Chia seeder, which maintains a list of reliable nodes within the Chia network via a built-in DNS server.Simplified UTXO based transaction model, with small on-chain stateLisp-style Turing-complete functionalprogramming languagefor money related use casesBLS keys and aggregate signatures (only one signature per block)Pooling protocolthat allows farmers to have control of making blocksSupport for light clients with fast, objective syncingA growing community of farmers and developers around the worldPlease check out theChia website, thewiki, andFAQfor
information on this project.Python 3.8.1+ is required. Make sure your default python version is >=3.8.1
by typingpython3.If you are behind a NAT, it can be difficult for peers outside your subnet to
reach you when they start up. You can enableUPnPon your router or add a NAT (for IPv4 but not IPv6) and firewall rules to allow
TCP port 8444 access to your peer.
These methods tend to be router make/model specific.Most users should only install harvesters, farmers, plotter, full nodes, and wallets.
Setting up a seeder is best left to more advanced users.
Building Timelords and VDFs is for sophisticated users, in most environments.
Chia Network and additional volunteers are running sufficient Timelords
for consensus.InstallingInstall instructions are available in theInstallation Detailssection of theChia Docs.RunningOnce installed, anIntroduction to Chiaguide is available in theChia Docs.
Package: chiadoge
chia-blockchainChiadogecoin is an open source peer-to-peer digital currency, created by chia project former developer and shiba community,favored by Shiba Inus worldwide.Chiadogecoin, a digital currency based on an open source, peer-to-peer internet protocol, is created by the former developers of the Chia project in collaboration with Shiba community that globally famous for Shiba Inu. One block of Chiadogecoin is generated in about 10 minutes, and halved in every three years. In the first year, each block generate 20000 Chiadogecoins, and it will be halved to 10000 coins at next third years, this model will run about 30 years and experience 9 halves. From the 31st to 99th year, each block generate constant 50 coins, and after the 100th year, block reward becomes 0. The total amount of Chiadogecoin is finally constant about 200 billion.InstallingInstall instructions are available in theINSTALLsection of thechia-blockchain repository wiki.RoadMapThe total amount of chiadoge is a constant, almost 200,000,000,000.halving every 3 years,detail see:Official website.CommunityTwitterDiscordReddit.Telegram.
Package: chiahub-monitor
chiahub-monitorThe official chia pooling protocol allows a pool to onlyestimatethe plot size for a
farmer. That's why we created a small helper program that connects to your farmer and retrieves the actual number of
plots you have. We don't use this to calculate your share (still using the official pooling protocol) but it enables the
pool to warn you if your actual plot size differs a lot from your estimated plot size. We believe in transparency that's why
we made this little helper open-sourceInstallationInstall Python3Create and activate a new environmentpython3 -m venv venv
source venv/bin/activate (Windows: venv\Scripts\activate.bat)Install chiahub-monitorpip install chiahub-monitorStart withpython -m chiahub_monitor.mainChiahub-monitor will automatically find your chia config.yaml and use it to connect to the local running farmer. Upon
retrieving plots known to the farmer it will upload that list to your farmers profile at chiahub.io.
Package: chia-internal-custody
Internal CustodyInstallYou need a running full node and wallet for most commands to work.  You don't need anything if you are just a signer. Here are the instructions for this piece:py -m venv venv
. ./venv/bin/activate  # ./venv/Scripts/activate for Windows users
pip install --extra-index-url https://pypi.chia.net/simple/ chia-internal-custodyIf you're on Windows, you need one extra package:pip install pyreadlineKey Generationhsmgen > 1.se
hsmgen > 2.se
hsmgen > 3.se
hsmpk $(cat 1.se) > 1.pk
hsmpk $(cat 2.se) > 2.pk
hsmpk $(cat 3.se) > 3.pkNote: If you're on windows powershell 5 or lower,>does not work properly.Either upgrade your shell or find some other way to put the output into a file as UTF-8.Configurationcic init --withdrawal-timelock 60 --payment-clawback 120 --rekey-cancel 120 --rekey-timelock 120 --slow-penalty 120
cic derive_root -pks "1.pk,2.pk,3.pk" -m 2 -n 3Launchcic launch_singleton --fee 100000000
cic sync -c './Configuration (<your 6 hex digits>).txt'
cic p2_address --prefix txch
<send money to that address and wait for confirmation>
cic syncPaymentcic payment -f initial_absorb.unsigned -pks "1.pk,2.pk" -a 100 -t <own address> -ap -at 0
cat ./initial_absorb.unsigned | hsms -y --nochunks 1.se
echo <sig here> > initial_absorb.1.sig
cat ./initial_absorb.unsigned | hsms -y --nochunks 2.se
echo <sig here> > initial_absorb.2.sig
hsmmerge ./initial_absorb.unsigned ./initial_absorb.1.sig ./initial_absorb.2.sig > initial_absorb.signed
cic push_tx -b ./initial_absorb.signed -m 100000000
cic syncClawbackcic clawback -f clawback.unsigned -pks "1.pk,2.pk"
cat ./clawback.unsigned | hsms -y --nochunks 1.se
echo <sig here> > clawback.1.sig
cat ./clawback.unsigned | hsms -y --nochunks 2.se
echo <sig here> > clawback.2.sig
hsmmerge ./clawback.unsigned ./clawback.1.sig ./clawback.2.sig > clawback.signed
cic push_tx -b ./clawback.signed -m 100000000
cic syncRe-configurecic derive_root --db-path './sync (<your hex digits>).sqlite' -c './Configuration (new).txt' -pks "1.pk,2.pk" -m 1 -n 2Rekeycic start_rekey -f rekey.unsigned -pks "1.pk,2.pk" -new './Configuration (new).txt'
cat ./rekey.unsigned | hsms -y --nochunks 1.se
echo <sig here> > rekey.1.sig
cat ./rekey.unsigned | hsms -y --nochunks 2.se
echo <sig here> > rekey.2.sig
hsmmerge ./rekey.unsigned ./rekey.1.sig ./rekey.2.sig > rekey.signed
cic push_tx -b ./rekey.signed -m 100000000
cic syncCompletecic complete -f complete.signed
cic push_tx -b ./complete.signed -m 100000000
cic syncUpdate DB configcic update_config -c './Configuration (new).txt'Increase securitycic increase_security_level -f lock.unsigned -pks "1.pk,2.pk"
cat ./lock.unsigned | hsms -y --nochunks 1.se
echo <sig here> > lock.1.sig
cat ./lock.unsigned | hsms -y --nochunks 2.se
echo <sig here> > lock.2.sig
hsmmerge ./lock.unsigned ./lock.1.sig ./lock.2.sig > lock.signed
cic push_tx -b ./lock.signed -m 100000000
cic sync
Package: chiakilisp
ChiakiLisp - Yet another LISPDemoQt5 Demo Source CodeLibrariesAll the libraries are written in pure ChiakiLisp and located in thelibrariesdirectory.Fujisaki- a small library that allows to write PyQt5 applications in a declarative way.DescriptionChiakiLisp- Yet another LISPThere are few similar projects:HyLang- compiles LISP into Python 3 bytecode, then interpretsLicense and contributionThis project is licensed under WTFPL license, that means that you cando whatever you want with this precious thing
Package: chialisp-builder
Chialisp BuilderUse this wheel in conjunction withruntime_builderto manage building of chialisp at build time or during development.UseAddchialisp_builderas a buildtime dependency and a development-time dependency. Don't add it as a runtime dependency, as the clvm.hexfiles should be built and included with the wheel. The source does not need to be.Addchialisp_loaderas a runtime dependency to get theload_programfunction, which will call the building function if present (as it should be at development time.)FAQWhy isn't this included as part ofruntime_builder?Theruntime_builderwheel is intended to provide a general solution for non-python artifacts. Although Chialisp build was the inspiration forruntime_builder, it's just one potential use. This wheel is the specific implementation of chialisp builds for use withruntime_builder.
Package: chialisp-loader
chialisp_loaderThis tiny wheel exportsload_program, which is used to loadchialispprograms from resources included with python wheels.Chialisp.clspfiles are compiled into.hexoutput. Only.hexoutput files need to be included in binary wheelsWhenload_programis called, it tries to importchialisp_builder. If it fails, it assumes this is running at deploy time: any.clspfiles are ignored, and the corresponding program is loaded from the.hexfile.
Package: chialisp-puzzles
chialisp_puzzlesThis project contains several standard and legacy puzzles commonly used on the chia network.Note that it usesensconsto build, as the more commonly usedsetuptoolsdoes not easily allow fine-grained control of the contents of thesdistandwheelfiles.In particular, this example takes pains to include the source filesruntime_buildor*.clspin the sdist but not the wheel.UseTo load a puzzle, do something likefromchialisp_puzzlesimportload_puzzleprogram=load_puzzle("p2_delegated_puzzle_or_hidden_puzzle")LicenseThis project is licensed under the Apache 2 License. See the LICENSE file for more details.
Package: chialisp-stdlib
chialisp_stdlibUse:pip install chialisp_stdlibTo get the path to the include files, usefromchialisp_stdlibimportNIGHTLY_INCLUDE_DIRECTORYfromchialisp_stdlibimportSTABLE_INCLUDE_DIRECTORYNote that*_INCLUDE_DIRECTORYis apathlib.Pathand not astr, so if your API expectsstr-based paths, usestr(path)to convert.And upgrade your API: seePEP519. C'mon, it's 2023 (as of this writing).
Package: chiapos
Chia Proof of SpaceChia's proof of space is written in C++. Includes a plotter, prover, and
verifier. It exclusively runs on 64 bit architectures. Read theProof of Space documentto
learn about what proof of space is and how it works.C++ Usage InstructionsCompile# Requires cmake 3.14+mkdir-pbuild&&cdbuild
cmake../
cmake--build.---j6Static Compilation With glibcStatically compile ProofOfSpacemkdir-pbuild&&cdbuild
cmake-DBUILD_PROOF_OF_SPACE_STATICALLY=ON../
cmake--build.---j6Run tests./RunTestsCLI usage./ProofOfSpace-k25-f"plot.dat"-m"0x1234"create
./ProofOfSpace-k25-f"final-plot.dat"-m"0x4567"-tTMPDIR-2SECOND_TMPDIRcreate
./ProofOfSpace-f"plot.dat"prove<32bytehexchallenge>
./ProofOfSpace-k25verify<hexproof><32bytehexchallenge>
./ProofOfSpace-f"plot.dat"check<iterations>Benchmarktime./ProofOfSpace-k25createHellman Attacks usageThere is an experimental implementation which implements some of the Hellman
Attacks that can provide significant space savings for the final file../HellmanAttacks-k18-f"plot.dat"-m"0x1234"create
./HellmanAttacks-f"plot.dat"check<iterations>PythonFinally, python bindings are provided in the python-bindings directory.Installpython3-mvenv.venv
..venv/bin/activate
pip3install.Run python testsTestings uses pytest. Linting uses flake8 and mypy.py.test./tests-s-vci BuildingThe primary build process for this repository is to use GitHub Actions to
build binary wheels for MacOS, Linux (x64 and aarch64), and Windows and publish
them with a source wheel on PyPi. See.github/workflows/build.yml. CMake usesFetchContentto downloadpybind11. Building is then
managed bycibuildwheel. Further
installation is then available viapip install chiapose.g.Contributing and workflowContributions are welcome and more details are available in chia-blockchain'sCONTRIBUTING.md.The main branch is usually the currently released latest version on PyPI.
Note that at times chiapos will be ahead of the release version that
chia-blockchain requires in it's main/release version in preparation for a
new chia-blockchain release. Please branch or fork main and then create a
pull request to the main branch. Linear merging is enforced on main and
merging requires a completed review. PRs will kick off a GitHub actions ci build
and analysis of chiapos atlgtm.com. Please
make sure your build is passing and that it does not increase alerts at lgtm.
Package: chiapos1
Chia Proof of SpaceChia's proof of space is written in C++. Includes a plotter, prover, and
verifier. It exclusively runs on 64 bit architectures. Read theProof of Space documentto
learn about what proof of space is and how it works.C++ Usage InstructionsCompile# Requires cmake 3.14+mkdir-pbuild&&cdbuild
cmake../
cmake--build.---j6Run tests./RunTestsCLI usage./ProofOfSpace-k25-f"plot.dat"-m"0x1234"create
./ProofOfSpace-k25-f"final-plot.dat"-m"0x4567"-tTMPDIR-2SECOND_TMPDIRcreate
./ProofOfSpace-f"plot.dat"prove<32bytehexchallenge>
./ProofOfSpace-k25verify<hexproof><32bytehexchallenge>
./ProofOfSpace-f"plot.dat"check<iterations>Benchmarktime./ProofOfSpace-k25createHellman Attacks usageThere is an experimental implementation which implements some of the Hellman
Attacks that can provide significant space savings for the final file../HellmanAttacks-k18-f"plot.dat"-m"0x1234"create
./HellmanAttacks-f"plot.dat"check<iterations>PythonFinally, python bindings are provided in the python-bindings directory.Installpython3-mvenv.venv
..venv/bin/activate
pip3install.Run python testsTestings uses pytest. Linting uses flake8 and mypy.py.test./tests-s-vci BuildingThe primary build process for this repository is to use GitHub Actions to
build binary wheels for MacOS, Linux (x64 and aarch64), and Windows and publish
them with a source wheel on PyPi. See.github/workflows/build.yml. CMake usesFetchContentto downloadpybind11. Building is then
managed bycibuildwheel. Further
installation is then available viapip install chiapose.g.Contributing and workflowContributions are welcome and more details are available in chia-blockchain'sCONTRIBUTING.md.The main branch is usually the currently released latest version on PyPI.
Note that at times chiapos will be ahead of the release version that
chia-blockchain requires in it's main/release version in preparation for a
new chia-blockchain release. Please branch or fork main and then create a
pull request to the main branch. Linear merging is enforced on main and
merging requires a completed review. PRs will kick off a GitHub actions ci build
and analysis of chiapos atlgtm.com. Please
make sure your build is passing and that it does not increase alerts at lgtm.
Package: chia-py-rpc
Chia-Py-RPCChia-Py-RPC is a Python library that provides a convenient way to interact with the Chia blockchain using the Chia RPC (Remote Procedure Call) protocol. It allows you to send transactions, check balances, and perform other Chia-related operations programmatically from Python.FeaturesSend transactions to multiple recipients in a single transactionCheck wallet balances and transaction historyGet information about Chia blocks, coins, and transactionsCreate and manage Chia walletsSimple and easy-to-usePlus every RPC method avaliable in Chia Client 1.7.0 or previous.InstallationTo install Chia-Py-RPC, you can usepip, the Python package manager. Open a terminal and run the following command:pipinstallchia-py-rpcUsageHere's an example of how you can use Chia-Py-RPC to send transactions to multiple recipients in a single transaction:from chia_py_rpc.wallet import Wallet

# Create an instance of Wallet
chia_wallet = Wallet()

# Specify the wallet ID, additions (recipients), fee, and optional parameters
wallet_id = 1
additions = [
    {'amount': 1000000000000, 'puzzle_hash': '0x...'},  # Recipient 1
    {'amount': 500000000000, 'puzzle_hash': '0x...'},  # Recipient 2
]
fee = 0.00001

# Call the send_transaction_multi method to send the transaction
result = chia_wallet.send_transaction_multi(wallet_id, additions, fee)

# Parse the result and handle the transaction ID and status
transaction_id = result['transaction_id']
status = result['status']
print(f"Transaction ID: {transaction_id}")
print(f"Status: {status}")For more examples and documentation, please refer to the official documentation.ContributingIf you would like to contribute to Chia-Py-RPC, please open an issue or submit a pull request on GitHub. We welcome any contributions, including bug fixes, feature enhancements, and documentation improvements.LicenseChia-Py-RPC is open-source software licensed under the MIT License.AcknowledgementsChia-Py-RPC is not affilated with the Chia Network in any way and it purely to provide a simple method of utlising Chia RPC in python.
Package: chiasm-shell
Python-based interactive assembler/disassembler CLI, powered byKeystone/Capstone.Why did you make this?I wanted to quickly view some opcodes withmetasm-shell.rb,
but I didn’t have a Metasploit install handy. I didn’t really want to
mess around with Ruby either, so I figured that writing my own
replacement was a good excuse to play with Keystone and Capstone.How do I install it?pipinstallchiasm-shell# ORmkvirtualenvchiasm-shell# optionalgitclonehttps://github.com/0xbc/chiasm-shellcdchiasm-shellpythonsetup.pyinstall# assumes you have Capstone and Keystone# build toolchains installed, which includes CMake.How do I run it?chiasm-shell# or, from the repo base directory:python-mchiasm_shell.chiasm_shellHow do I use it?When the prompt isasm>, you’re using the interactive assembler
backend (Keystone).Input one or more assembly statements separated by a semi-colon. x86
uses Intel syntax only at the moment.When the prompt isdisasm>, you’re using the interactive
disassembler backend (Capstone).Input one or more bytes represented by \xXX, where XX is a hex
value.To switch backends, useswitch asmorswitch disasm.To change architecture, usesetarch <arch> <mode(s)>.e.g.setarch x86 64.You can use more than one mode, separated by spaces.Uselsarchandlsmodeto view supported architectures and
modes for the current backendAt the moment, you need to know what modes are relevant to each
architecture - check the Keystone/Capstone source if you’re not sure.Typehelpto see a list of commands;help <cmd>to see the
docstring forcmd.Example usagesasm> inc eax; xor ebx, ebx
\x40\x31\xdbdisasm> \x40\x31\xdb
0x1000: inc     eax
0x1001: xor     ebx, ebxIt’s broken/I have a suggestion/etc.Please get in touch/raise an issue/PR/etc!Known IssuesNone at this time.TODOSyntax highlighting and/or tab completion for assemblyIntelligent mode selectionSupport different input/output formatsTest suite
Package: chia-tea
Chia Tea 🌱🍵Chia Tea is a tools and utility library for the Chia Cryptocurrency.
We are building tools in this library to serve our own needs and share our work openly with others.
Feel free to use them and make your life easier 💚Table of ContentsIntro and FAQQuick-StartArchitecture SummaryStructure of this repositoryFeature OverviewCopy ToolMonitoringDiscord BotContributionsAbout Us✊ Support Us ✊Structure of this repositoryFeature OverviewCopy ToolCopy is a tool to copy your chia files to a different location. It can be faster to plot to a temporary storage space and then move the plots to your harvester afterwards to not block the plotting queue. We manage this process through our copy cli tool. It incorporates the following features:Selects a drive with sufficient space from multiple disks specifiedChecks drive space regularlyTakes plots which are being copied already into accountUses the drive with the fewest copy processesLogs transfer timesMonitoringThe monitoring tracks everything relevant to a Chia farm, including harvesters, farmers, plotters, etc. It consists of a server and multiple clients. The server is run on only one machine. It stores all the monitoring data in a sqlite database. The clients are the data collectors and are typically run on plotters, harvesters, farmers, etc. Simply start them on the same machine and they will collect data automatically. You can run both server and client on the same machine if you have a single machine setup.Discord BotThe discord module is a bot watching a farm and reports major incidents. Internally the bot keeps an eye on the sqlite database thus a running monitoring server is required. Besides notifications the bot also provides commands to interact with the chia farm.About UsWe are a small group of professional engineers and software developers doing Chia for fun. Join ourDiscord Serverfor questions, tips and tricks or just come over for a nice warm cup of your favourite tea.ContributionsDue to security concerns, we only accept small PR's with limited complexity to our codebase.✊ Support Us ✊The more you support us, the easier we can make your life as a Chia farmer. Every little bit helps and motivates us to do more.CurrencyAddressChiaxch13yrhjp0zleepsafjh8syh0jyakjgat9fzlut575lq0z5jywmydeqy05awjBTCbc1qwjyh0fu708zv0yqdmp098tq465qy64jpmqpj4yETH0xeeaA95F8816208b4bb8D070ab571941843246029ADAaddr1qxc2amr663yfh9z4cdk8d6hkv9apvm35dm5lkgjdlu6ffkfggrvustlynuxzqmswee4mvd6cfeu66hq788rmgts2uggq7qtuqh
Package: chia-xch
chia-xchA simple python package interacts with the chia node, python version >=3.6 is recommendInstallpip3 install chia-xchGroupsconnectconnectfrom chia_xch.xch import Xch
from chia_xch.providers import *
fnp = FullNodeProvider()
fn = Xch.full_node(fnp)

wp = WalletProvider()
wa = Xch.wallet(wp)TipsThe default parameters of these functions are not specified in the document, you need to check the source code by yourself.The current document is incomplete, I will gradually improve the document later.