chore: register aleo token adapters

Author: troykessler

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

@@ -71,7 +71,7 @@ export class AleoProvider extends AleoBase implements AltVM.IProvider {
 
   async getTotalSupply(req: AltVM.ReqGetTotalSupply): Promise<bigint> {
     if (!req.denom) {
-      throw new Error(`Can not get total supply of credits`);
+      return 0n;
     }
 
     const result = await this.aleoClient.getProgramMappingValue(

typescript/sdk/src/token/Token.ts

@@ -28,6 +28,11 @@ import {
   TokenStandard,
   XERC20_STANDARDS,
 } from './TokenStandard.js';
+import {
+  AleoHypCollateralAdapter,
+  AleoHypSyntheticAdapter,
+  AleoNativeTokenAdapter,
+} from './adapters/AleoTokenAdapter.js';
 import {
   CwHypCollateralAdapter,
   CwHypNativeAdapter,
@@ -173,6 +178,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 +353,14 @@ export class Token implements IToken {
       return new RadixHypSyntheticAdapter(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,

typescript/sdk/src/token/adapters/AleoTokenAdapter.ts

@@ -1,12 +1,26 @@
 import { AleoProvider, AleoTransaction } from '@hyperlane-xyz/aleo-sdk';
-import { Address, Numberish, assert } from '@hyperlane-xyz/utils';
+import {
+  Address,
+  Domain,
+  Numberish,
+  addressToBytes32,
+  assert,
+  strip0x,
+} from '@hyperlane-xyz/utils';
 
 import { BaseAleoAdapter } from '../../app/MultiProtocolApp.js';
 import { MultiProtocolProvider } from '../../providers/MultiProtocolProvider.js';
 import { ChainName } from '../../types.js';
 import { TokenMetadata } from '../types.js';
 
-import { ITokenAdapter, TransferParams } from './ITokenAdapter.js';
+import {
+  IHypTokenAdapter,
+  ITokenAdapter,
+  InterchainGasQuote,
+  QuoteTransferRemoteParams,
+  TransferParams,
+  TransferRemoteParams,
+} from './ITokenAdapter.js';
 
 export class AleoTokenAdapter
   extends BaseAleoAdapter
@@ -15,6 +29,10 @@ export class AleoTokenAdapter
   protected provider: AleoProvider;
   protected tokenAddress: string;
 
+  protected async getDenom(): Promise<string> {
+    return this.tokenAddress;
+  }
+
   constructor(
     public readonly chainName: ChainName,
     public readonly multiProvider: MultiProtocolProvider,
@@ -27,20 +45,35 @@ export class AleoTokenAdapter
   }
 
   async getBalance(address: Address): Promise<bigint> {
+    const denom = await this.getDenom();
     return this.provider.getBalance({
       address,
+      denom,
     });
   }
 
   async getMetadata(): Promise<TokenMetadata> {
-    const nativeToken = await this.provider.getToken({
+    const { name, symbol, decimals } = await this.provider.getToken({
       tokenAddress: this.tokenAddress,
     });
 
+    assert(
+      name !== undefined,
+      `name on radix token ${this.tokenAddress} is undefined`,
+    );
+    assert(
+      symbol !== undefined,
+      `symbol on radix token ${this.tokenAddress} is undefined`,
+    );
+    assert(
+      decimals !== undefined,
+      `divisibility on radix token ${this.tokenAddress} is undefined`,
+    );
+
     return {
-      name: nativeToken.name,
-      symbol: nativeToken.symbol,
-      decimals: nativeToken.decimals,
+      name,
+      symbol,
+      decimals,
     };
   }
 
@@ -70,18 +103,167 @@ export class AleoTokenAdapter
   async populateTransferTx(
     transferParams: TransferParams,
   ): Promise<AleoTransaction> {
+    const denom = await this.getDenom();
+
     assert(transferParams.fromAccountOwner, `no sender in transfer params`);
 
     return this.provider.getTransferTransaction({
       signer: transferParams.fromAccountOwner,
       recipient: transferParams.recipient,
-      denom: '',
+      denom,
       amount: transferParams.weiAmountOrId.toString(),
     });
   }
 
   async getTotalSupply(): Promise<bigint | undefined> {
-    // Not implemented, native tokens don't have an accessible total supply
-    return undefined;
+    const denom = await this.getDenom();
+    return this.provider.getTotalSupply({
+      denom,
+    });
+  }
+}
+
+export class AleoNativeTokenAdapter
+  extends AleoTokenAdapter
+  implements ITokenAdapter<AleoTransaction>
+{
+  override async getMetadata(): Promise<TokenMetadata> {
+    const { nativeToken } = this.multiProvider.getChainMetadata(this.chainName);
+    assert(
+      nativeToken,
+      `Native token data is required for ${AleoNativeTokenAdapter.name}`,
+    );
+
+    return {
+      name: nativeToken.name,
+      symbol: nativeToken.symbol,
+      decimals: nativeToken.decimals,
+    };
   }
 }
+
+export class AleoHypCollateralAdapter
+  extends AleoTokenAdapter
+  implements IHypTokenAdapter<AleoTransaction>
+{
+  constructor(
+    public readonly chainName: ChainName,
+    public readonly multiProvider: MultiProtocolProvider,
+    public readonly addresses: { token: Address },
+  ) {
+    super(chainName, multiProvider, addresses);
+  }
+
+  protected async getResourceAddress(): Promise<string> {
+    const { denom } = await this.provider.getToken({
+      tokenAddress: this.tokenAddress,
+    });
+    return denom;
+  }
+
+  async getDomains(): Promise<Domain[]> {
+    const { remoteRouters } = await this.provider.getRemoteRouters({
+      tokenAddress: this.tokenAddress,
+    });
+
+    return remoteRouters.map((router) => router.receiverDomainId);
+  }
+
+  async getRouterAddress(domain: Domain): Promise<Buffer> {
+    const { remoteRouters } = await this.provider.getRemoteRouters({
+      tokenAddress: this.tokenAddress,
+    });
+
+    const router = remoteRouters.find(
+      (router) => router.receiverDomainId === domain,
+    );
+
+    if (!router) {
+      throw new Error(`Router with domain "${domain}" not found`);
+    }
+
+    return Buffer.from(strip0x(router.receiverAddress), 'hex');
+  }
+
+  async getAllRouters(): Promise<Array<{ domain: Domain; address: Buffer }>> {
+    const { remoteRouters } = await this.provider.getRemoteRouters({
+      tokenAddress: this.tokenAddress,
+    });
+
+    return remoteRouters.map((router) => ({
+      domain: router.receiverDomainId,
+      address: Buffer.from(strip0x(router.receiverAddress), 'hex'),
+    }));
+  }
+
+  async getBridgedSupply(): Promise<bigint | undefined> {
+    return this.provider.getBridgedSupply({
+      tokenAddress: this.tokenAddress,
+    });
+  }
+
+  async quoteTransferRemoteGas({
+    destination,
+  }: QuoteTransferRemoteParams): Promise<InterchainGasQuote> {
+    const { denom: addressOrDenom, amount } =
+      await this.provider.quoteRemoteTransfer({
+        tokenAddress: this.tokenAddress,
+        destinationDomainId: destination,
+      });
+
+    return {
+      igpQuote: {
+        addressOrDenom,
+        amount,
+      },
+    };
+  }
+
+  async populateTransferRemoteTx(
+    params: TransferRemoteParams,
+  ): Promise<AleoTransaction> {
+    assert(params.fromAccountOwner, `no sender in remote transfer params`);
+
+    if (!params.interchainGas) {
+      params.interchainGas = await this.quoteTransferRemoteGas({
+        destination: params.destination,
+      });
+    }
+
+    const { remoteRouters } = await this.provider.getRemoteRouters({
+      tokenAddress: this.tokenAddress,
+    });
+
+    const router = remoteRouters.find(
+      (router) => router.receiverDomainId === params.destination,
+    );
+
+    if (!router) {
+      throw new Error(
+        `Failed to find remote router for token id and destination: ${this.tokenAddress},${params.destination}`,
+      );
+    }
+
+    if (!params.interchainGas.igpQuote?.addressOrDenom) {
+      throw new Error(
+        `Require denom for max fee, didn't receive and denom in the interchainGas quote`,
+      );
+    }
+
+    return this.provider.getRemoteTransferTransaction({
+      signer: params.fromAccountOwner!,
+      tokenAddress: this.tokenAddress,
+      destinationDomainId: params.destination,
+      recipient: strip0x(addressToBytes32(params.recipient)),
+      amount: params.weiAmountOrId.toString(),
+      customHookAddress: params.customHook,
+      gasLimit: router.gas,
+      maxFee: {
+        denom: params.interchainGas.igpQuote?.addressOrDenom,
+        amount: params.interchainGas.igpQuote?.amount.toString(),
+      },
+    });
+  }
+}
+
+export class AleoHypSyntheticAdapter extends AleoHypCollateralAdapter {}