feat: aleo nexus support (#7822)

Author: troykessler

.changeset/ninety-rivers-shave.md

@@ -0,0 +1,7 @@
+---
+'@hyperlane-xyz/aleo-sdk': major
+'@hyperlane-xyz/widgets': major
+'@hyperlane-xyz/sdk': major
+---
+
+feat: aleo nexus ui support

package.json

@@ -59,7 +59,6 @@
     "patchedDependencies": {
       "typechain@8.3.2": "patches/typechain@8.3.2.patch",
       "node-fetch@2.7.0": "patches/node-fetch@2.7.0.patch",
-      "@provablehq/sdk@0.9.14": "patches/@provablehq__sdk@0.9.14.patch",
       "bigint-buffer@1.1.5": "patches/bigint-buffer@1.1.5.patch",
       "node-fetch@3.3.2": "patches/node-fetch@3.3.2.patch"
     }

patches/@provablehq__sdk@0.9.14.patch

@@ -58,7 +58,7 @@
   "dependencies": {
     "@hyperlane-xyz/provider-sdk": "workspace:*",
     "@hyperlane-xyz/utils": "workspace:*",
-    "@provablehq/sdk": "0.9.14",
+    "@provablehq/sdk": "0.9.15",
     "bignumber.js": "catalog:",
     "unzipper": "^0.12.3"
   },

pnpm-lock.yaml

@@ -54,7 +54,15 @@ import {
 
 import { AleoBase } from './base.js';
 
+interface TransactionFeeCache {
+  [key: string]: {
+    fee: bigint;
+  };
+}
+
 export class AleoProvider extends AleoBase implements AltVM.IProvider {
+  private transactionFeeCache: TransactionFeeCache = {};
+
   static async connect(
     rpcUrls: string[],
     chainId: string | number,
@@ -139,12 +147,27 @@ export class AleoProvider extends AleoBase implements AltVM.IProvider {
   async estimateTransactionFee(
     req: AltVM.ReqEstimateTransactionFee<AleoTransaction>,
   ): Promise<AltVM.ResEstimateTransactionFee> {
+    const cacheKey = `${req.transaction.programName}:${req.transaction.functionName}`;
+
+    const cached = this.transactionFeeCache[cacheKey];
+    if (cached) {
+      return {
+        fee: cached.fee,
+        gasUnits: 0n,
+        gasPrice: 0,
+      };
+    }
+
     const programManager = this.getProgramManager();
     const fee = await programManager.estimateExecutionFee({
       programName: req.transaction.programName,
       functionName: req.transaction.functionName,
     });
 
+    this.transactionFeeCache[cacheKey] = {
+      fee,
+    };
+
     return {
       fee,
       gasUnits: 0n,

typescript/aleo-sdk/package.json

@@ -5,6 +5,7 @@ import { MultiProtocolProvider } from '../providers/MultiProtocolProvider.js';
 import { TypedTransactionReceipt } from '../providers/ProviderType.js';
 import { ChainMap, ChainName } from '../types.js';
 
+import { AleoCoreAdapter } from './adapters/AleoCoreAdapter.js';
 import { CosmNativeCoreAdapter } from './adapters/CosmNativeCoreAdapter.js';
 import { CosmWasmCoreAdapter } from './adapters/CosmWasmCoreAdapter.js';
 import { EvmCoreAdapter } from './adapters/EvmCoreAdapter.js';
@@ -45,6 +46,7 @@ export class MultiProtocolCore extends MultiProtocolApp<
     if (protocol === ProtocolType.CosmosNative) return CosmNativeCoreAdapter;
     if (protocol === ProtocolType.Starknet) return StarknetCoreAdapter;
     if (protocol === ProtocolType.Radix) return RadixCoreAdapter;
+    if (protocol === ProtocolType.Aleo) return AleoCoreAdapter;
     throw new Error(`No adapter for protocol ${protocol}`);
   }
 

typescript/aleo-sdk/src/clients/provider.ts

@@ -0,0 +1,60 @@
+import { Address, HexString, assert, pollAsync } from '@hyperlane-xyz/utils';
+
+import { BaseAleoAdapter } from '../../app/MultiProtocolApp.js';
+import { MultiProtocolProvider } from '../../providers/MultiProtocolProvider.js';
+import {
+  ProviderType,
+  TypedTransactionReceipt,
+} from '../../providers/ProviderType.js';
+import { ChainName } from '../../types.js';
+
+import { ICoreAdapter } from './types.js';
+
+export class AleoCoreAdapter extends BaseAleoAdapter implements ICoreAdapter {
+  constructor(
+    public readonly chainName: ChainName,
+    public readonly multiProvider: MultiProtocolProvider<any>,
+    public readonly addresses: { mailbox: Address },
+  ) {
+    super(chainName, multiProvider, addresses);
+  }
+
+  extractMessageIds(
+    sourceTx: TypedTransactionReceipt,
+  ): Array<{ messageId: string; destination: ChainName }> {
+    assert(
+      sourceTx.type === ProviderType.Aleo,
+      `Unsupported provider type for AleoCoreAdapter ${sourceTx.type}`,
+    );
+
+    return [];
+  }
+
+  async waitForMessageProcessed(
+    messageId: HexString,
+    destination: ChainName,
+    delayMs?: number,
+    maxAttempts?: number,
+  ): Promise<boolean> {
+    const provider = this.multiProvider.getAleoProvider(destination);
+
+    await pollAsync(
+      async () => {
+        this.logger.debug(`Checking if message ${messageId} was processed`);
+        const delivered = await provider.isMessageDelivered({
+          mailboxAddress: this.addresses.mailbox,
+          messageId: messageId,
+        });
+
+        assert(delivered, `Message ${messageId} not yet processed`);
+
+        this.logger.info(`Message ${messageId} was processed`);
+        return delivered;
+      },
+      delayMs,
+      maxAttempts,
+    );
+
+    return true;
+  }
+}

typescript/sdk/src/core/MultiProtocolCore.ts

@@ -97,6 +97,8 @@ export function getExplorerTxUrl(
     'proteustestnet',
     'radix',
     'radixtestnet',
+    'aleo',
+    'aleotestnet',
   ].includes(chainName)
     ? 'transaction'
     : 'tx';

typescript/sdk/src/core/adapters/AleoCoreAdapter.ts

@@ -28,6 +28,12 @@ import {
   TokenStandard,
   XERC20_STANDARDS,
 } from './TokenStandard.js';
+import {
+  AleoHypCollateralAdapter,
+  AleoHypNativeAdapter,
+  AleoHypSyntheticAdapter,
+  AleoNativeTokenAdapter,
+} from './adapters/AleoTokenAdapter.js';
 import {
   CwHypCollateralAdapter,
   CwHypNativeAdapter,
@@ -173,6 +179,10 @@ export class Token implements IToken {
       return new RadixNativeTokenAdapter(chainName, multiProvider, {
         token: addressOrDenom,
       });
+    } else if (standard === TokenStandard.AleoNative) {
+      return new AleoNativeTokenAdapter(chainName, multiProvider, {
+        token: addressOrDenom,
+      });
     } else if (this.isHypToken()) {
       return this.getHypAdapter(multiProvider);
     } else if (this.isIbcToken()) {
@@ -344,6 +354,18 @@ export class Token implements IToken {
       return new RadixHypSyntheticAdapter(chainName, multiProvider, {
         token: addressOrDenom,
       });
+    } else if (standard === TokenStandard.AleoHypNative) {
+      return new AleoHypNativeAdapter(chainName, multiProvider, {
+        token: addressOrDenom,
+      });
+    } else if (standard === TokenStandard.AleoHypCollateral) {
+      return new AleoHypCollateralAdapter(chainName, multiProvider, {
+        token: addressOrDenom,
+      });
+    } else if (standard === TokenStandard.AleoHypSynthetic) {
+      return new AleoHypSyntheticAdapter(chainName, multiProvider, {
+        token: addressOrDenom,
+      });
     } else if (standard === TokenStandard.EvmM0PortalLite) {
       assert(
         collateralAddressOrDenom,