@hyperlane-xyz/sdk
Version:
The official SDK for the Hyperlane Network
190 lines • 7.09 kB
JavaScript
import { ALEO_NATIVE_DENOM, } from '@hyperlane-xyz/aleo-sdk/runtime';
import { addressToBytes32, assert, strip0x, } from '@hyperlane-xyz/utils';
import { BaseAleoAdapter } from '../../app/MultiProtocolApp.js';
export class AleoTokenAdapter extends BaseAleoAdapter {
chainName;
multiProvider;
addresses;
provider;
tokenAddress;
async getDenom() {
return ALEO_NATIVE_DENOM;
}
constructor(chainName, multiProvider, addresses) {
super(chainName, multiProvider, addresses);
this.chainName = chainName;
this.multiProvider = multiProvider;
this.addresses = addresses;
this.provider = this.getProvider();
this.tokenAddress = addresses.token;
}
async getBalance(address) {
const denom = await this.getDenom();
return this.provider.getBalance({
address,
denom,
});
}
async getMetadata() {
const { name, symbol, decimals } = await this.provider.getToken({
tokenAddress: this.tokenAddress,
});
assert(name !== undefined, `name on aleo token ${this.tokenAddress} is undefined`);
assert(symbol !== undefined, `symbol on aleo token ${this.tokenAddress} is undefined`);
assert(decimals !== undefined, `decimals on aleo token ${this.tokenAddress} is undefined`);
return {
name,
symbol,
decimals,
};
}
async getMinimumTransferAmount(_recipient) {
return 0n;
}
async isApproveRequired(_owner, _spender, _weiAmountOrId) {
return false;
}
async isRevokeApprovalRequired(_owner, _spender) {
return false;
}
async populateApproveTx(_params) {
throw new Error('Approve not required for native tokens');
}
async populateTransferTx(transferParams) {
const denom = await this.getDenom();
assert(transferParams.fromAccountOwner, `no sender in transfer params`);
return this.provider.getTransferTransaction({
signer: transferParams.fromAccountOwner,
recipient: transferParams.recipient,
denom,
amount: transferParams.weiAmountOrId.toString(),
});
}
async getTotalSupply() {
const denom = await this.getDenom();
return this.provider.getTotalSupply({
denom,
});
}
}
export class AleoNativeTokenAdapter extends AleoTokenAdapter {
async getMetadata() {
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 BaseAleoHypTokenAdapter extends AleoTokenAdapter {
chainName;
multiProvider;
addresses;
constructor(chainName, multiProvider, addresses) {
super(chainName, multiProvider, addresses);
this.chainName = chainName;
this.multiProvider = multiProvider;
this.addresses = addresses;
}
async getDenom() {
const { denom } = await this.provider.getToken({
tokenAddress: this.tokenAddress,
});
return denom;
}
async getDomains() {
const { remoteRouters } = await this.provider.getRemoteRouters({
tokenAddress: this.tokenAddress,
});
return remoteRouters.map((router) => router.receiverDomainId);
}
async getRouterAddress(domain) {
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() {
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() {
return this.provider.getBridgedSupply({
tokenAddress: this.tokenAddress,
});
}
async quoteTransferRemoteGas({ destination, customHook, }) {
const { denom: addressOrDenom, amount } = await this.provider.quoteRemoteTransfer({
tokenAddress: this.tokenAddress,
destinationDomainId: destination,
customHookAddress: customHook,
});
return {
igpQuote: {
addressOrDenom,
amount,
},
};
}
async populateTransferRemoteTx(params) {
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 a 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 AleoHypCollateralAdapter extends BaseAleoHypTokenAdapter {
}
export class AleoHypSyntheticAdapter extends BaseAleoHypTokenAdapter {
}
export class AleoHypNativeAdapter extends BaseAleoHypTokenAdapter {
async getDenom() {
return ALEO_NATIVE_DENOM;
}
async getMetadata() {
const { nativeToken } = this.multiProvider.getChainMetadata(this.chainName);
assert(nativeToken, `Native token data is required for ${AleoHypNativeAdapter.name}`);
return {
name: nativeToken.name,
symbol: nativeToken.symbol,
decimals: nativeToken.decimals,
};
}
}
//# sourceMappingURL=AleoTokenAdapter.js.map