UNPKG

@galacticcouncil/descriptors

Version:

Hydration papi (polkadot-api) descriptors

github.com/galacticcouncil/sdk

galacticcouncil/sdk

2 lines • 642 kB
1
2
// .papi/descriptors/src/hydration_metadata.ts var binMeta = "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