@alephium/powfi-sdk 0.0.1-rc.1

package/src/token/token.ts

@@ -0,0 +1,163 @@
+import type { TokenInfo } from '@alephium/token-list';
+import ModuleBase from '../moduleBase';
+import type { Zeta } from '../zeta';
+import { TokenListFetchError } from '../common/error';
+
+interface TokenCache {
+  tokens: TokenInfo[];
+  lastFetched: Date;
+}
+
+type TokenListResponse = {
+  tokens: TokenInfo[];
+};
+
+export class TokenModule extends ModuleBase {
+  private cache?: TokenCache;
+  private readonly cacheTimeMs: number;
+
+  constructor(
+    scope: Zeta,
+    private readonly cacheTimeDays: number = 1,
+  ) {
+    super({ scope, moduleName: 'TokenModule' });
+
+    this.scope = scope;
+    this.cacheTimeMs = cacheTimeDays * 24 * 60 * 60 * 1000;
+  }
+
+  async getTokens(): Promise<TokenInfo[]> {
+    if (this.isCacheValid()) {
+      return this.cache!.tokens;
+    }
+
+    try {
+      return await this.fetchTokens();
+    } catch (error) {
+      if (this.cache) {
+        const reason = error instanceof Error ? error.message : String(error);
+        this.logInfo(`Failed to refresh token list, using cached copy. Reason: ${reason}`);
+        return this.cache.tokens;
+      }
+      this.logAndThrowError(`Failed to refresh token list`, error);
+    }
+  }
+
+  async getTokenById(id: string): Promise<TokenInfo> {
+    const tokenInfo = await this.getTokenInfoBy((token) => token.id === id);
+    if (!tokenInfo) {
+      throw new Error(`Unknown token, id not found in token list: ${id}`);
+    }
+    return tokenInfo;
+  }
+
+  async getTokenBySymbol(symbol: string): Promise<TokenInfo> {
+    const tokenInfo = await this.getTokenInfoBy((token) => token.symbol === symbol);
+    if (!tokenInfo) {
+      throw new Error(`Unknown token, symbol not found in token list: ${symbol}`);
+    }
+    return tokenInfo;
+  }
+
+  async getTokenInfoBy(fn: (token: TokenInfo) => boolean): Promise<TokenInfo | undefined> {
+    const tokenInfoz = await this.getTokens();
+    return tokenInfoz.find(fn);
+  }
+
+  async fetchTokens(): Promise<TokenInfo[]> {
+    try {
+      const response = await fetch(this.scope.tokenListUrl);
+      if (!response.ok) {
+        throw new TokenListFetchError(this.scope.tokenListUrl, { status: response.status });
+      }
+      const payload: unknown = await response.json();
+      const tokens = this.extractTokens(payload);
+      this.cache = {
+        tokens,
+        lastFetched: new Date(),
+      };
+
+      return tokens;
+    } catch (error) {
+      if (error instanceof TokenListFetchError) {
+        this.logAndThrowError(`Failed to fetch token list`, error);
+      }
+
+      this.logAndThrowError(
+        `Failed to fetch token list`,
+        new TokenListFetchError(this.scope.tokenListUrl, {
+          cause: error,
+        }),
+      );
+    }
+  }
+
+  private isCacheValid(): boolean {
+    if (!this.cache) {
+      return false;
+    }
+
+    const now = new Date();
+    const timeDiff = now.getTime() - this.cache.lastFetched.getTime();
+    return timeDiff < this.cacheTimeMs;
+  }
+
+  private extractTokens(payload: unknown): TokenInfo[] {
+    if (!this.validateTokenListResponse(payload)) {
+      throw new Error('Invalid token list payload received from token list endpoint');
+    }
+    return payload.tokens;
+  }
+
+  private validateTokenListResponse(value: unknown): value is TokenListResponse {
+    if (typeof value !== 'object' || value === null) {
+      return false;
+    }
+    const tokens = (value as { tokens?: unknown }).tokens;
+    if (!Array.isArray(tokens)) {
+      return false;
+    }
+    return tokens.every((token) => this.validateTokenInfo(token));
+  }
+
+  private validateTokenInfo(value: unknown): value is TokenInfo {
+    if (typeof value !== 'object' || value === null) {
+      return false;
+    }
+
+    const token = value as Partial<TokenInfo>;
+
+    const requiredStringFields: Array<keyof TokenInfo> = [
+      'id',
+      'name',
+      'symbol',
+      'description',
+      'logoURI',
+    ];
+
+    if (requiredStringFields.some((field) => typeof token[field] !== 'string')) {
+      return false;
+    }
+
+    const { decimals, originChain, unchainedLogoURI } = token;
+
+    if (
+      typeof decimals !== 'number' ||
+      !Number.isInteger(decimals) ||
+      decimals < 0 ||
+      decimals > 255
+    ) {
+      return false;
+    }
+
+    if (originChain !== undefined && typeof originChain !== 'string') {
+      return false;
+    }
+
+    if (unchainedLogoURI !== undefined && typeof unchainedLogoURI !== 'string') {
+      return false;
+    }
+
+    return true;
+  }
+}

package/src/zeta.ts

@@ -0,0 +1,105 @@
+import type { SignerProvider, Account } from '@alephium/web3';
+import { NodeProvider, ExplorerProvider, web3 } from '@alephium/web3';
+import { CpmmModule } from './cpmm/cpmm';
+import type { Network, ZetaLoadParams } from './common/types';
+import { defaultNetworks } from './common/types';
+import { ClmmModule } from './clmm/clmm';
+import { TokenModule } from './token/token';
+import { StakingModule } from './staking/staking';
+
+export class Zeta {
+  public cpmm: CpmmModule;
+  public clmm: ClmmModule;
+  public token: TokenModule;
+  public staking: StakingModule;
+
+  private _nodeProvider: NodeProvider;
+  private _explorerProvider: ExplorerProvider;
+  private _tokenListUrl: string;
+  private _signer?: SignerProvider;
+  private _account?: Account;
+  private _network: Network;
+
+  constructor(params: ZetaLoadParams) {
+    const network = defaultNetworks.find((n) => n.id === params.networkId);
+    if (!network) {
+      throw new Error(`Network ${params.networkId} not found`);
+    }
+
+    const overrides = params.networkOverrides ?? {};
+    const networkConfig: Network = { ...network, ...overrides };
+
+    this._network = networkConfig;
+    this._nodeProvider = new NodeProvider(this._network.nodeUrl, this._network.nodeApiKey);
+    this._explorerProvider = new ExplorerProvider(this._network.explorerApiUrl);
+    this._tokenListUrl = this._network.tokenListUrl;
+    this._signer = params.signer;
+
+    // Initialize modules
+    this.cpmm = new CpmmModule(this);
+    this.clmm = new ClmmModule(this);
+    this.token = new TokenModule(this);
+    this.staking = new StakingModule(this);
+  }
+
+  static load(config: ZetaLoadParams): Zeta {
+    return new Zeta(config);
+  }
+
+  public set signer(signer: SignerProvider) {
+    this._signer = signer;
+  }
+
+  public set account(account: Account) {
+    this._account = account;
+  }
+
+  get signer(): SignerProvider {
+    if (!this._signer) {
+      throw new Error('Signer not set');
+    }
+    return this._signer;
+  }
+
+  get account(): Account {
+    if (!this._account) {
+      throw new Error('Account not set');
+    }
+    return this._account;
+  }
+
+  public clearSigner() {
+    this._signer = undefined;
+  }
+
+  public clearAccount() {
+    this._account = undefined;
+  }
+
+  get nodeProvider(): NodeProvider {
+    return this._nodeProvider;
+  }
+
+  get explorerProvider(): ExplorerProvider {
+    return this._explorerProvider;
+  }
+
+  get network(): Network {
+    return this._network;
+  }
+
+  get tokenListUrl(): string {
+    return this._tokenListUrl;
+  }
+
+  public setCurrentProviders(): void {
+    if (!this._nodeProvider) {
+      throw new Error('Node provider not set');
+    }
+    if (!this._explorerProvider) {
+      throw new Error('Explorer provider not set');
+    }
+    web3.setCurrentNodeProvider(this._nodeProvider);
+    web3.setCurrentExplorerProvider(this._explorerProvider);
+  }
+}

package/staking/artifacts/AlphStakeAndLock.ral.json

@@ -0,0 +1,31 @@
+{
+  "version": "v4.2.5",
+  "name": "AlphStakeAndLock",
+  "bytecodeTemplate": "01010300020018b417001600{2}a2{2}0d0c{0}010c0c0d{1}010c170116001601{2}a3{2}0d0c{1}010f",
+  "fieldsSig": {
+    "names": [
+      "xAlphToken",
+      "xAlphStakeVault",
+      "amount"
+    ],
+    "types": [
+      "XAlphToken",
+      "XAlphStakeVault",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "functions": [
+    {
+      "name": "main",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    }
+  ]
+}

package/staking/artifacts/AlphUnstakeVault.ral.json

@@ -0,0 +1,151 @@
+{
+  "version": "v4.2.5",
+  "name": "AlphUnstakeVault",
+  "bytecode": "060540ea40f841384172418c0000030901409216020c3013415e7b160016010c0d3687170316001601371704160316043616031604314c020d4a010c36170516050c2f4c04160416022d02160216053313415f7b160016011602871706160516061604334c020d4a010c361705160416063617040c1602361602381707160216072d1702160416072d17040c16073616072d0d351707160416051607373917040f1602370e3a170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e160216083736371708160416083702010000000103d3f10c9d97ce020201000003014020d3223281b2ce040c3313167b5617001600ce033413177b1600ce032b1701ce0217021601ce04314c0516021601ce04000017021602a0002b0201020102011fd30e00e856b417011601ce0077457a4b04181601ce014513147b160000023213157bce011600a8a00016002aa100a000ce022f0201020001000bd38e18691cb417001600ce00774513147bce01b0",
+  "codeHash": "5216c458f360d0f51f5e2109a760814ff97eab76f546adc835eb318c6cbc5256",
+  "fieldsSig": {
+    "names": [
+      "xalphToken",
+      "unstakerAddress",
+      "totalUnstakeAmount",
+      "unstakeStartTime",
+      "unstakeDuration",
+      "withdrawnAmount"
+    ],
+    "types": [
+      "XAlphToken",
+      "Address",
+      "U256",
+      "U256",
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      true
+    ]
+  },
+  "eventsSig": [],
+  "functions": [
+    {
+      "name": "mulDiv",
+      "paramNames": [
+        "a",
+        "b",
+        "denominator"
+      ],
+      "paramTypes": [
+        "U256",
+        "U256",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false,
+        true
+      ],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "getTotalUnstakeAmount",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "getClaimableAmount",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "claim",
+      "paramNames": [
+        "amount"
+      ],
+      "paramTypes": [
+        "U256"
+      ],
+      "paramIsMutable": [
+        false
+      ],
+      "returnTypes": [
+        "Bool"
+      ]
+    },
+    {
+      "name": "destroy",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    }
+  ],
+  "constants": [],
+  "enums": [
+    {
+      "name": "FullMathError",
+      "fields": [
+        {
+          "name": "DivByZero",
+          "value": {
+            "type": "U256",
+            "value": "350"
+          }
+        },
+        {
+          "name": "MulDivOverflow",
+          "value": {
+            "type": "U256",
+            "value": "351"
+          }
+        }
+      ]
+    },
+    {
+      "name": "ErrorCodes",
+      "fields": [
+        {
+          "name": "InvalidCaller",
+          "value": {
+            "type": "U256",
+            "value": "20"
+          }
+        },
+        {
+          "name": "InsufficientClaimableAmount",
+          "value": {
+            "type": "U256",
+            "value": "21"
+          }
+        },
+        {
+          "name": "InvalidUnstakeDuration",
+          "value": {
+            "type": "U256",
+            "value": "22"
+          }
+        },
+        {
+          "name": "InvalidTimestamp",
+          "value": {
+            "type": "U256",
+            "value": "23"
+          }
+        }
+      ]
+    }
+  ]
+}