@hyperlane-xyz/radix-sdk 0.0.0-beta-20251201221151

package/README.md

@@ -0,0 +1,43 @@
+# Hyperlane Radix SDK
+
+The Hyperlane Radix SDK is a fully typed TypeScript SDK for the [Radix Implementation](https://github.com/hyperlane-xyz/hyperlane-radix).
+It can be used as a standalone SDK for frontend or in backend applications which want to connect to a Radix chain which has the Hyperlane blueprint installed.
+
+## Install
+
+```bash
+# Install with NPM
+npm install @hyperlane-xyz/radix-sdk
+
+# Or with Yarn
+yarn add @hyperlane-xyz/radix-sdk
+```
+
+## Usage
+
+```ts
+import { RadixSDK, RadixSigningSDK } from "@hyperlane-xyz/radix-sdk";
+
+const signingSdk = await RadixSigningSDK.fromPrivateKey(
+  PRIV_KEY,
+  {
+    networkId: NetworkId.Stokenet,
+  },
+);
+
+const mailboxAddress = await signingSdk.tx.createMailbox({ domain_id: 75898670 });
+
+const mailbox = await signingSdk.query.getMailbox({ mailbox: mailboxAddress });
+...
+
+// performing queries without signer
+const sdk = new RadixSDK({
+  networkId: NetworkId.Stokenet,
+})
+
+const mailbox = await signingSdk.query.getMailbox({ mailbox: mailboxAddress });
+```
+
+## Setup
+
+Node 18 or newer is required.

package/dist/clients/protocol.d.ts

@@ -0,0 +1,9 @@
+import { AltVM, ChainMetadataForAltVM, ITransactionSubmitter, ProtocolProvider, SignerConfig, TransactionSubmitterConfig } from '@hyperlane-xyz/provider-sdk';
+import { IProvider } from '@hyperlane-xyz/provider-sdk/altvm';
+import { AnnotatedTx, TxReceipt } from '@hyperlane-xyz/provider-sdk/module';
+export declare class RadixProtocolProvider implements ProtocolProvider {
+    createProvider(chainMetadata: ChainMetadataForAltVM): Promise<IProvider>;
+    createSigner(chainMetadata: ChainMetadataForAltVM, config: SignerConfig): Promise<AltVM.ISigner<AnnotatedTx, TxReceipt>>;
+    createSubmitter<TConfig extends TransactionSubmitterConfig>(_chainMetadata: ChainMetadataForAltVM, _config: TConfig): Promise<ITransactionSubmitter>;
+}
+//# sourceMappingURL=protocol.d.ts.map

package/dist/clients/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/clients/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,YAAY,EACZ,0BAA0B,EAC3B,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAC9D,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAC;AAM5E,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D,cAAc,CAAC,aAAa,EAAE,qBAAqB,GAAG,OAAO,CAAC,SAAS,CAAC;IAQlE,YAAY,CAChB,aAAa,EAAE,qBAAqB,EACpC,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IAQjD,eAAe,CAAC,OAAO,SAAS,0BAA0B,EACxD,cAAc,EAAE,qBAAqB,EACrC,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,qBAAqB,CAAC;CAIlC"}

package/dist/clients/protocol.js

@@ -0,0 +1,23 @@
+import { assert } from '@hyperlane-xyz/utils';
+import { RadixProvider } from './provider.js';
+import { RadixSigner } from './signer.js';
+export class RadixProtocolProvider {
+    createProvider(chainMetadata) {
+        assert(chainMetadata.rpcUrls, 'rpc urls undefined');
+        const rpcUrls = chainMetadata.rpcUrls.map((rpc) => rpc.http);
+        return RadixProvider.connect(rpcUrls, chainMetadata.chainId, {
+            metadata: chainMetadata,
+        });
+    }
+    async createSigner(chainMetadata, config) {
+        assert(chainMetadata.rpcUrls, 'rpc urls undefined');
+        const rpcUrls = chainMetadata.rpcUrls.map((rpc) => rpc.http);
+        const { privateKey, ...extraParams } = config;
+        return RadixSigner.connectWithSigner(rpcUrls, privateKey, extraParams);
+    }
+    createSubmitter(_chainMetadata, _config) {
+        // @TODO Implement in a follow up PR
+        throw Error('Not implemented');
+    }
+}
+//# sourceMappingURL=protocol.js.map

package/dist/clients/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/clients/protocol.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,OAAO,qBAAqB;IAChC,cAAc,CAAC,aAAoC;QACjD,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC7D,OAAO,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,EAAE;YAC3D,QAAQ,EAAE,aAAa;SACxB,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,YAAY,CAChB,aAAoC,EACpC,MAAoB;QAEpB,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,oBAAoB,CAAC,CAAC;QACpD,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAE7D,MAAM,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,GAAG,MAAM,CAAC;QAC9C,OAAO,WAAW,CAAC,iBAAiB,CAAC,OAAO,EAAE,UAAU,EAAE,WAAW,CAAC,CAAC;IACzE,CAAC;IAED,eAAe,CACb,cAAqC,EACrC,OAAgB;QAEhB,oCAAoC;QACpC,MAAM,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACjC,CAAC;CACF"}

package/dist/clients/provider.d.ts

@@ -0,0 +1,77 @@
+import { GatewayApiClient } from '@radixdlt/babylon-gateway-api-sdk';
+import { AltVM } from '@hyperlane-xyz/provider-sdk';
+import { RadixCorePopulate } from '../core/populate.js';
+import { RadixCoreQuery } from '../core/query.js';
+import { RadixBase } from '../utils/base.js';
+import { RadixSDKOptions, RadixSDKTransaction } from '../utils/types.js';
+import { RadixWarpPopulate } from '../warp/populate.js';
+import { RadixWarpQuery } from '../warp/query.js';
+export declare class RadixProvider implements AltVM.IProvider<RadixSDKTransaction> {
+    protected rpcUrls: string[];
+    protected networkId: number;
+    protected gateway: GatewayApiClient;
+    protected applicationName: string;
+    protected packageAddress: string;
+    protected base: RadixBase;
+    protected query: {
+        core: RadixCoreQuery;
+        warp: RadixWarpQuery;
+    };
+    protected populate: {
+        core: RadixCorePopulate;
+        warp: RadixWarpPopulate;
+    };
+    static connect(rpcUrls: string[], chainId: string | number, extraParams?: Record<string, any>): Promise<RadixProvider>;
+    constructor(options: RadixSDKOptions);
+    isHealthy(): Promise<boolean>;
+    getRpcUrls(): string[];
+    getHeight(): Promise<number>;
+    getBalance(req: AltVM.ReqGetBalance): Promise<bigint>;
+    getTotalSupply(req: AltVM.ReqGetTotalSupply): Promise<bigint>;
+    estimateTransactionFee(req: AltVM.ReqEstimateTransactionFee<RadixSDKTransaction>): Promise<AltVM.ResEstimateTransactionFee>;
+    getMailbox(req: AltVM.ReqGetMailbox): Promise<AltVM.ResGetMailbox>;
+    isMessageDelivered(req: AltVM.ReqIsMessageDelivered): Promise<boolean>;
+    getIsmType(req: AltVM.ReqGetIsmType): Promise<AltVM.IsmType>;
+    getMessageIdMultisigIsm(req: AltVM.ReqMessageIdMultisigIsm): Promise<AltVM.ResMessageIdMultisigIsm>;
+    getMerkleRootMultisigIsm(req: AltVM.ReqMerkleRootMultisigIsm): Promise<AltVM.ResMerkleRootMultisigIsm>;
+    getRoutingIsm(req: AltVM.ReqRoutingIsm): Promise<AltVM.ResRoutingIsm>;
+    getNoopIsm(req: AltVM.ReqNoopIsm): Promise<AltVM.ResNoopIsm>;
+    getHookType(req: AltVM.ReqGetHookType): Promise<AltVM.HookType>;
+    getInterchainGasPaymasterHook(req: AltVM.ReqGetInterchainGasPaymasterHook): Promise<AltVM.ResGetInterchainGasPaymasterHook>;
+    getMerkleTreeHook(req: AltVM.ReqGetMerkleTreeHook): Promise<AltVM.ResGetMerkleTreeHook>;
+    getNoopHook(_req: AltVM.ReqGetNoopHook): Promise<AltVM.ResGetNoopHook>;
+    getToken(req: AltVM.ReqGetToken): Promise<AltVM.ResGetToken>;
+    getRemoteRouters(req: AltVM.ReqGetRemoteRouters): Promise<AltVM.ResGetRemoteRouters>;
+    getBridgedSupply(req: AltVM.ReqGetBridgedSupply): Promise<bigint>;
+    quoteRemoteTransfer(req: AltVM.ReqQuoteRemoteTransfer): Promise<AltVM.ResQuoteRemoteTransfer>;
+    getCreateMailboxTransaction(req: AltVM.ReqCreateMailbox): Promise<RadixSDKTransaction>;
+    getSetDefaultIsmTransaction(req: AltVM.ReqSetDefaultIsm): Promise<RadixSDKTransaction>;
+    getSetDefaultHookTransaction(req: AltVM.ReqSetDefaultHook): Promise<RadixSDKTransaction>;
+    getSetRequiredHookTransaction(req: AltVM.ReqSetRequiredHook): Promise<RadixSDKTransaction>;
+    getSetMailboxOwnerTransaction(req: AltVM.ReqSetMailboxOwner): Promise<RadixSDKTransaction>;
+    getCreateMerkleRootMultisigIsmTransaction(req: AltVM.ReqCreateMerkleRootMultisigIsm): Promise<RadixSDKTransaction>;
+    getCreateMessageIdMultisigIsmTransaction(req: AltVM.ReqCreateMessageIdMultisigIsm): Promise<RadixSDKTransaction>;
+    getCreateRoutingIsmTransaction(req: AltVM.ReqCreateRoutingIsm): Promise<RadixSDKTransaction>;
+    getSetRoutingIsmRouteTransaction(req: AltVM.ReqSetRoutingIsmRoute): Promise<RadixSDKTransaction>;
+    getRemoveRoutingIsmRouteTransaction(req: AltVM.ReqRemoveRoutingIsmRoute): Promise<RadixSDKTransaction>;
+    getSetRoutingIsmOwnerTransaction(req: AltVM.ReqSetRoutingIsmOwner): Promise<RadixSDKTransaction>;
+    getCreateNoopIsmTransaction(req: AltVM.ReqCreateNoopIsm): Promise<RadixSDKTransaction>;
+    getCreateMerkleTreeHookTransaction(req: AltVM.ReqCreateMerkleTreeHook): Promise<RadixSDKTransaction>;
+    getCreateInterchainGasPaymasterHookTransaction(req: AltVM.ReqCreateInterchainGasPaymasterHook): Promise<RadixSDKTransaction>;
+    getSetInterchainGasPaymasterHookOwnerTransaction(req: AltVM.ReqSetInterchainGasPaymasterHookOwner): Promise<RadixSDKTransaction>;
+    getSetDestinationGasConfigTransaction(req: AltVM.ReqSetDestinationGasConfig): Promise<RadixSDKTransaction>;
+    getRemoveDestinationGasConfigTransaction(_req: AltVM.ReqRemoveDestinationGasConfig): Promise<RadixSDKTransaction>;
+    getCreateNoopHookTransaction(_req: AltVM.ReqCreateNoopHook): Promise<RadixSDKTransaction>;
+    getCreateValidatorAnnounceTransaction(req: AltVM.ReqCreateValidatorAnnounce): Promise<RadixSDKTransaction>;
+    getCreateNativeTokenTransaction(_req: AltVM.ReqCreateNativeToken): Promise<RadixSDKTransaction>;
+    getCreateCollateralTokenTransaction(req: AltVM.ReqCreateCollateralToken): Promise<RadixSDKTransaction>;
+    getCreateSyntheticTokenTransaction(req: AltVM.ReqCreateSyntheticToken): Promise<RadixSDKTransaction>;
+    getSetTokenOwnerTransaction(req: AltVM.ReqSetTokenOwner): Promise<RadixSDKTransaction>;
+    getSetTokenIsmTransaction(req: AltVM.ReqSetTokenIsm): Promise<RadixSDKTransaction>;
+    getSetTokenHookTransaction(_req: AltVM.ReqSetTokenHook): Promise<RadixSDKTransaction>;
+    getEnrollRemoteRouterTransaction(req: AltVM.ReqEnrollRemoteRouter): Promise<RadixSDKTransaction>;
+    getUnenrollRemoteRouterTransaction(req: AltVM.ReqUnenrollRemoteRouter): Promise<RadixSDKTransaction>;
+    getTransferTransaction(req: AltVM.ReqTransfer): Promise<RadixSDKTransaction>;
+    getRemoteTransferTransaction(req: AltVM.ReqRemoteTransfer): Promise<RadixSDKTransaction>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/clients/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/clients/provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAGrE,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAGpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAGL,eAAe,EACf,mBAAmB,EACpB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAoBlD,qBAAa,aAAc,YAAW,KAAK,CAAC,SAAS,CAAC,mBAAmB,CAAC;IACxE,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAC5B,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,OAAO,EAAE,gBAAgB,CAAC;IAEpC,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC;IAEjC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC;IAC1B,SAAS,CAAC,KAAK,EAAE;QACf,IAAI,EAAE,cAAc,CAAC;QACrB,IAAI,EAAE,cAAc,CAAC;KACtB,CAAC;IACF,SAAS,CAAC,QAAQ,EAAE;QAClB,IAAI,EAAE,iBAAiB,CAAC;QACxB,IAAI,EAAE,iBAAiB,CAAC;KACzB,CAAC;WAEW,OAAO,CAClB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,OAAO,CAAC,aAAa,CAAC;gBAab,OAAO,EAAE,eAAe;IAiD9B,SAAS;IAIf,UAAU,IAAI,MAAM,EAAE;IAMhB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAI5B,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IASrD,cAAc,CAAC,GAAG,EAAE,KAAK,CAAC,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAQ7D,sBAAsB,CAC1B,GAAG,EAAE,KAAK,CAAC,yBAAyB,CAAC,mBAAmB,CAAC,GACxD,OAAO,CAAC,KAAK,CAAC,yBAAyB,CAAC;IAQrC,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC;IAIlE,kBAAkB,CAAC,GAAG,EAAE,KAAK,CAAC,qBAAqB,GAAG,OAAO,CAAC,OAAO,CAAC;IAOtE,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IAuB5D,uBAAuB,CAC3B,GAAG,EAAE,KAAK,CAAC,uBAAuB,GACjC,OAAO,CAAC,KAAK,CAAC,uBAAuB,CAAC;IAenC,wBAAwB,CAC5B,GAAG,EAAE,KAAK,CAAC,wBAAwB,GAClC,OAAO,CAAC,KAAK,CAAC,wBAAwB,CAAC;IAepC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC;IAMrE,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC;IAa5D,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC;IAiB/D,6BAA6B,CACjC,GAAG,EAAE,KAAK,CAAC,gCAAgC,GAC1C,OAAO,CAAC,KAAK,CAAC,gCAAgC,CAAC;IAI5C,iBAAiB,CACrB,GAAG,EAAE,KAAK,CAAC,oBAAoB,GAC9B,OAAO,CAAC,KAAK,CAAC,oBAAoB,CAAC;IAIhC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC;IAMtE,QAAQ,CAAC,GAAG,EAAE,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC;IAmB5D,gBAAgB,CACpB,GAAG,EAAE,KAAK,CAAC,mBAAmB,GAC7B,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC;IAI/B,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAIjE,mBAAmB,CACvB,GAAG,EAAE,KAAK,CAAC,sBAAsB,GAChC,OAAO,CAAC,KAAK,CAAC,sBAAsB,CAAC;IASlC,2BAA2B,CAC/B,GAAG,EAAE,KAAK,CAAC,gBAAgB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAUzB,2BAA2B,CAC/B,GAAG,EAAE,KAAK,CAAC,gBAAgB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,4BAA4B,CAChC,GAAG,EAAE,KAAK,CAAC,iBAAiB,GAC3B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,6BAA6B,CACjC,GAAG,EAAE,KAAK,CAAC,kBAAkB,GAC5B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,6BAA6B,CACjC,GAAG,EAAE,KAAK,CAAC,kBAAkB,GAC5B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,yCAAyC,CAC7C,GAAG,EAAE,KAAK,CAAC,8BAA8B,GACxC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,wCAAwC,CAC5C,GAAG,EAAE,KAAK,CAAC,6BAA6B,GACvC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,8BAA8B,CAClC,GAAG,EAAE,KAAK,CAAC,mBAAmB,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IAUzB,gCAAgC,CACpC,GAAG,EAAE,KAAK,CAAC,qBAAqB,GAC/B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,mCAAmC,CACvC,GAAG,EAAE,KAAK,CAAC,wBAAwB,GAClC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,gCAAgC,CACpC,GAAG,EAAE,KAAK,CAAC,qBAAqB,GAC/B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,2BAA2B,CAC/B,GAAG,EAAE,KAAK,CAAC,gBAAgB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IASzB,kCAAkC,CACtC,GAAG,EAAE,KAAK,CAAC,uBAAuB,GACjC,OAAO,CAAC,mBAAmB,CAAC;IAUzB,8CAA8C,CAClD,GAAG,EAAE,KAAK,CAAC,mCAAmC,GAC7C,OAAO,CAAC,mBAAmB,CAAC;IAYzB,gDAAgD,CACpD,GAAG,EAAE,KAAK,CAAC,qCAAqC,GAC/C,OAAO,CAAC,mBAAmB,CAAC;IAWzB,qCAAqC,CACzC,GAAG,EAAE,KAAK,CAAC,0BAA0B,GACpC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,wCAAwC,CAC5C,IAAI,EAAE,KAAK,CAAC,6BAA6B,GACxC,OAAO,CAAC,mBAAmB,CAAC;IAMzB,4BAA4B,CAChC,IAAI,EAAE,KAAK,CAAC,iBAAiB,GAC5B,OAAO,CAAC,mBAAmB,CAAC;IAIzB,qCAAqC,CACzC,GAAG,EAAE,KAAK,CAAC,0BAA0B,GACpC,OAAO,CAAC,mBAAmB,CAAC;IAYzB,+BAA+B,CACnC,IAAI,EAAE,KAAK,CAAC,oBAAoB,GAC/B,OAAO,CAAC,mBAAmB,CAAC;IAIzB,mCAAmC,CACvC,GAAG,EAAE,KAAK,CAAC,wBAAwB,GAClC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,kCAAkC,CACtC,GAAG,EAAE,KAAK,CAAC,uBAAuB,GACjC,OAAO,CAAC,mBAAmB,CAAC;IAazB,2BAA2B,CAC/B,GAAG,EAAE,KAAK,CAAC,gBAAgB,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAWzB,yBAAyB,CAC7B,GAAG,EAAE,KAAK,CAAC,cAAc,GACxB,OAAO,CAAC,mBAAmB,CAAC;IAWzB,0BAA0B,CAC9B,IAAI,EAAE,KAAK,CAAC,eAAe,GAC1B,OAAO,CAAC,mBAAmB,CAAC;IAIzB,gCAAgC,CACpC,GAAG,EAAE,KAAK,CAAC,qBAAqB,GAC/B,OAAO,CAAC,mBAAmB,CAAC;IAazB,kCAAkC,CACtC,GAAG,EAAE,KAAK,CAAC,uBAAuB,GACjC,OAAO,CAAC,mBAAmB,CAAC;IAWzB,sBAAsB,CAC1B,GAAG,EAAE,KAAK,CAAC,WAAW,GACrB,OAAO,CAAC,mBAAmB,CAAC;IAczB,4BAA4B,CAChC,GAAG,EAAE,KAAK,CAAC,iBAAiB,GAC3B,OAAO,CAAC,mBAAmB,CAAC;CAmBhC"}

package/dist/clients/provider.js

@@ -0,0 +1,486 @@
+import { GatewayApiClient } from '@radixdlt/babylon-gateway-api-sdk';
+import { NetworkId } from '@radixdlt/radix-engine-toolkit';
+import { AltVM } from '@hyperlane-xyz/provider-sdk';
+import { assert } from '@hyperlane-xyz/utils';
+import { RadixCorePopulate } from '../core/populate.js';
+import { RadixCoreQuery } from '../core/query.js';
+import { RadixBase } from '../utils/base.js';
+import { RadixHookTypes, RadixIsmTypes, } from '../utils/types.js';
+import { RadixWarpPopulate } from '../warp/populate.js';
+import { RadixWarpQuery } from '../warp/query.js';
+const DEFAULT_GAS_MULTIPLIER = 1.2;
+const NETWORKS = {
+    [NetworkId.Stokenet]: {
+        applicationName: 'hyperlane',
+        packageAddress: 'package_tdx_2_1pkn2zdcw8q8rax6mxetdkgp7493mf379afhq7a7peh4wnftz3zej4h',
+    },
+    [NetworkId.Mainnet]: {
+        applicationName: 'hyperlane',
+        packageAddress: 'package_rdx1pkzmcj4mtal34ddx9jrt8um6u3yqheqpfvcj4s0ulmgyt094fw0jzh',
+    },
+    [NetworkId.LocalNet]: {
+        applicationName: 'hyperlane',
+    },
+};
+export class RadixProvider {
+    rpcUrls;
+    networkId;
+    gateway;
+    applicationName;
+    packageAddress;
+    base;
+    query;
+    populate;
+    static async connect(rpcUrls, chainId, extraParams) {
+        const networkId = parseInt(chainId.toString());
+        return new RadixProvider({
+            rpcUrls,
+            networkId,
+            gatewayUrls: extraParams?.metadata?.gatewayUrls?.map(({ http }) => http),
+            packageAddress: extraParams?.metadata?.packageAddress,
+        });
+    }
+    constructor(options) {
+        this.rpcUrls = options.rpcUrls;
+        this.networkId = options.networkId ?? NetworkId.Mainnet;
+        const networkBaseConfig = NETWORKS[this.networkId];
+        assert(networkBaseConfig, `Network with id ${this.networkId} not supported with the Hyperlane RadixSDK. Supported network ids: ${Object.keys(NETWORKS).join(', ')}`);
+        this.applicationName = networkBaseConfig.applicationName;
+        const packageAddress = options.packageAddress ?? networkBaseConfig.packageAddress;
+        assert(packageAddress, `Expected package address to be defined for radix network with id ${this.networkId}`);
+        this.packageAddress = packageAddress;
+        this.gateway = GatewayApiClient.initialize({
+            applicationName: this.applicationName,
+            basePath: options.gatewayUrls?.[0],
+            networkId: this.networkId,
+        });
+        this.base = new RadixBase(this.networkId, this.gateway, options.gasMultiplier ?? DEFAULT_GAS_MULTIPLIER);
+        this.query = {
+            core: new RadixCoreQuery(this.networkId, this.gateway, this.base),
+            warp: new RadixWarpQuery(this.networkId, this.gateway, this.base),
+        };
+        this.populate = {
+            core: new RadixCorePopulate(this.gateway, this.base, this.packageAddress),
+            warp: new RadixWarpPopulate(this.gateway, this.base, this.query.warp, this.packageAddress),
+        };
+    }
+    // ### QUERY BASE ###
+    async isHealthy() {
+        return this.base.isGatewayHealthy();
+    }
+    getRpcUrls() {
+        return this.rpcUrls;
+    }
+    // in RadixDLT there are no blocks, but we can use the ledger state version
+    // which has a similar concept
+    async getHeight() {
+        return this.base.getStateVersion();
+    }
+    async getBalance(req) {
+        assert(req.denom, `denom required by ${RadixProvider.name}`);
+        return this.base.getBalance({
+            address: req.address,
+            resource: req.denom,
+        });
+    }
+    async getTotalSupply(req) {
+        assert(req.denom, `denom required by ${RadixProvider.name}`);
+        return this.base.getTotalSupply({
+            resource: req.denom,
+        });
+    }
+    async estimateTransactionFee(req) {
+        return this.base.estimateTransactionFee({
+            transactionManifest: req.transaction.manifest,
+        });
+    }
+    // ### QUERY CORE ###
+    async getMailbox(req) {
+        return this.query.core.getMailbox({ mailbox: req.mailboxAddress });
+    }
+    async isMessageDelivered(req) {
+        return this.query.core.isMessageDelivered({
+            mailbox: req.mailboxAddress,
+            message_id: req.messageId,
+        });
+    }
+    async getIsmType(req) {
+        const ismType = await this.query.core.getIsmType({
+            ism: req.ismAddress,
+        });
+        switch (ismType) {
+            case RadixIsmTypes.MERKLE_ROOT_MULTISIG: {
+                return AltVM.IsmType.MERKLE_ROOT_MULTISIG;
+            }
+            case RadixIsmTypes.MESSAGE_ID_MULTISIG: {
+                return AltVM.IsmType.MESSAGE_ID_MULTISIG;
+            }
+            case RadixIsmTypes.ROUTING_ISM: {
+                return AltVM.IsmType.ROUTING;
+            }
+            case RadixIsmTypes.NOOP_ISM: {
+                return AltVM.IsmType.TEST_ISM;
+            }
+            default:
+                throw new Error(`Unknown ISM ModuleType: ${ismType}`);
+        }
+    }
+    async getMessageIdMultisigIsm(req) {
+        const ism = await this.query.core.getMultisigIsm({ ism: req.ismAddress });
+        assert(ism.type === RadixIsmTypes.MESSAGE_ID_MULTISIG, `ism with address ${req.ismAddress} is no ${RadixIsmTypes.MESSAGE_ID_MULTISIG}`);
+        return {
+            address: ism.address,
+            validators: ism.validators,
+            threshold: ism.threshold,
+        };
+    }
+    async getMerkleRootMultisigIsm(req) {
+        const ism = await this.query.core.getMultisigIsm({ ism: req.ismAddress });
+        assert(ism.type === RadixIsmTypes.MERKLE_ROOT_MULTISIG, `ism with address ${req.ismAddress} is no ${RadixIsmTypes.MERKLE_ROOT_MULTISIG}`);
+        return {
+            address: ism.address,
+            validators: ism.validators,
+            threshold: ism.threshold,
+        };
+    }
+    async getRoutingIsm(req) {
+        return this.query.core.getRoutingIsm({
+            ism: req.ismAddress,
+        });
+    }
+    async getNoopIsm(req) {
+        const ism = await this.query.core.getMultisigIsm({ ism: req.ismAddress });
+        assert(ism.type === RadixIsmTypes.NOOP_ISM, `ism with address ${req.ismAddress} is no ${RadixIsmTypes.NOOP_ISM}`);
+        return {
+            address: req.ismAddress,
+        };
+    }
+    async getHookType(req) {
+        const hookType = await this.query.core.getHookType({
+            hook: req.hookAddress,
+        });
+        switch (hookType) {
+            case RadixHookTypes.IGP: {
+                return AltVM.HookType.INTERCHAIN_GAS_PAYMASTER;
+            }
+            case RadixHookTypes.MERKLE_TREE: {
+                return AltVM.HookType.MERKLE_TREE;
+            }
+            default:
+                throw new Error(`Unknown Hook Type: ${hookType}`);
+        }
+    }
+    async getInterchainGasPaymasterHook(req) {
+        return this.query.core.getIgpHook({ hook: req.hookAddress });
+    }
+    async getMerkleTreeHook(req) {
+        return this.query.core.getMerkleTreeHook({ hook: req.hookAddress });
+    }
+    async getNoopHook(_req) {
+        throw new Error(`Noop Hook is currently not supported on Radix`);
+    }
+    // ### QUERY WARP ###
+    async getToken(req) {
+        const token = await this.query.warp.getToken({ token: req.tokenAddress });
+        switch (token.tokenType) {
+            case 'Collateral':
+                return {
+                    ...token,
+                    tokenType: AltVM.TokenType.collateral,
+                };
+            case 'Synthetic':
+                return {
+                    ...token,
+                    tokenType: AltVM.TokenType.synthetic,
+                };
+            default:
+                throw new Error(`Unknown Token Type: ${token.tokenType}`);
+        }
+    }
+    async getRemoteRouters(req) {
+        return this.query.warp.getRemoteRouters({ token: req.tokenAddress });
+    }
+    async getBridgedSupply(req) {
+        return this.query.warp.getBridgedSupply({ token: req.tokenAddress });
+    }
+    async quoteRemoteTransfer(req) {
+        return this.query.warp.quoteRemoteTransfer({
+            token: req.tokenAddress,
+            destination_domain: req.destinationDomainId,
+        });
+    }
+    // ### GET CORE TXS ###
+    async getCreateMailboxTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createMailbox({
+                from_address: req.signer,
+                domain_id: req.domainId,
+            }),
+        };
+    }
+    async getSetDefaultIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setDefaultIsm({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                ism: req.ismAddress,
+            }),
+        };
+    }
+    async getSetDefaultHookTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setDefaultHook({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                hook: req.hookAddress,
+            }),
+        };
+    }
+    async getSetRequiredHookTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setRequiredHook({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                hook: req.hookAddress,
+            }),
+        };
+    }
+    async getSetMailboxOwnerTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setMailboxOwner({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                new_owner: req.newOwner,
+            }),
+        };
+    }
+    async getCreateMerkleRootMultisigIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createMerkleRootMultisigIsm({
+                from_address: req.signer,
+                validators: req.validators,
+                threshold: req.threshold,
+            }),
+        };
+    }
+    async getCreateMessageIdMultisigIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createMessageIdMultisigIsm({
+                from_address: req.signer,
+                validators: req.validators,
+                threshold: req.threshold,
+            }),
+        };
+    }
+    async getCreateRoutingIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createRoutingIsm({
+                from_address: req.signer,
+                routes: req.routes,
+            }),
+        };
+    }
+    async getSetRoutingIsmRouteTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setRoutingIsmRoute({
+                from_address: req.signer,
+                ism: req.ismAddress,
+                route: req.route,
+            }),
+        };
+    }
+    async getRemoveRoutingIsmRouteTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.removeRoutingIsmRoute({
+                from_address: req.signer,
+                ism: req.ismAddress,
+                domain: req.domainId,
+            }),
+        };
+    }
+    async getSetRoutingIsmOwnerTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setRoutingIsmOwner({
+                from_address: req.signer,
+                ism: req.ismAddress,
+                new_owner: req.newOwner,
+            }),
+        };
+    }
+    async getCreateNoopIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createNoopIsm({
+                from_address: req.signer,
+            }),
+        };
+    }
+    async getCreateMerkleTreeHookTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createMerkleTreeHook({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+            }),
+        };
+    }
+    async getCreateInterchainGasPaymasterHookTransaction(req) {
+        assert(req.denom, `denom required by ${RadixProvider.name}`);
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createIgp({
+                from_address: req.signer,
+                denom: req.denom,
+            }),
+        };
+    }
+    async getSetInterchainGasPaymasterHookOwnerTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setIgpOwner({
+                from_address: req.signer,
+                igp: req.hookAddress,
+                new_owner: req.newOwner,
+            }),
+        };
+    }
+    async getSetDestinationGasConfigTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.setDestinationGasConfig({
+                from_address: req.signer,
+                igp: req.hookAddress,
+                destinationGasConfig: req.destinationGasConfig,
+            }),
+        };
+    }
+    async getRemoveDestinationGasConfigTransaction(_req) {
+        throw new Error(`RemoveDestinationGasConfig is currently not supported on Radix`);
+    }
+    async getCreateNoopHookTransaction(_req) {
+        throw new Error(`CreateNoopHook is currently not supported on Radix`);
+    }
+    async getCreateValidatorAnnounceTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.core.createValidatorAnnounce({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+            }),
+        };
+    }
+    // ### GET WARP TXS ###
+    async getCreateNativeTokenTransaction(_req) {
+        throw new Error(`Native Token is not supported on Radix`);
+    }
+    async getCreateCollateralTokenTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.createCollateralToken({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                origin_denom: req.collateralDenom,
+            }),
+        };
+    }
+    async getCreateSyntheticTokenTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.createSyntheticToken({
+                from_address: req.signer,
+                mailbox: req.mailboxAddress,
+                name: req.name,
+                symbol: req.denom,
+                divisibility: req.decimals,
+            }),
+        };
+    }
+    async getSetTokenOwnerTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.setTokenOwner({
+                from_address: req.signer,
+                token: req.tokenAddress,
+                new_owner: req.newOwner,
+            }),
+        };
+    }
+    async getSetTokenIsmTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.setTokenIsm({
+                from_address: req.signer,
+                token: req.tokenAddress,
+                ism: req.ismAddress,
+            }),
+        };
+    }
+    async getSetTokenHookTransaction(_req) {
+        throw new Error(`SetTokenHook is currently not supported on Radix`);
+    }
+    async getEnrollRemoteRouterTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.enrollRemoteRouter({
+                from_address: req.signer,
+                token: req.tokenAddress,
+                receiver_domain: req.remoteRouter.receiverDomainId,
+                receiver_address: req.remoteRouter.receiverAddress,
+                gas: req.remoteRouter.gas,
+            }),
+        };
+    }
+    async getUnenrollRemoteRouterTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.unenrollRemoteRouter({
+                from_address: req.signer,
+                token: req.tokenAddress,
+                receiver_domain: req.receiverDomainId,
+            }),
+        };
+    }
+    async getTransferTransaction(req) {
+        assert(req.denom, `denom required by ${RadixProvider.name}`);
+        return {
+            networkId: this.networkId,
+            manifest: await this.base.transfer({
+                from_address: req.signer,
+                to_address: req.recipient,
+                amount: req.amount,
+                resource_address: req.denom,
+            }),
+        };
+    }
+    async getRemoteTransferTransaction(req) {
+        return {
+            networkId: this.networkId,
+            manifest: await this.populate.warp.remoteTransfer({
+                from_address: req.signer,
+                token: req.tokenAddress,
+                destination_domain: req.destinationDomainId,
+                recipient: req.recipient,
+                amount: req.amount,
+                custom_hook_id: req.customHookAddress || '',
+                gas_limit: req.gasLimit,
+                custom_hook_metadata: req.customHookMetadata || '',
+                max_fee: {
+                    amount: req.maxFee.amount,
+                    denom: req.maxFee.denom,
+                },
+            }),
+        };
+    }
+}
+//# sourceMappingURL=provider.js.map