@xswap-link/sdk 0.10.8 → 0.10.9

package/src/services/svm/bindings/types/BaseChain.ts

@@ -0,0 +1,92 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface BaseChainFields {
+  remote: types.RemoteConfigFields
+  inboundRateLimit: types.RateLimitTokenBucketFields
+  outboundRateLimit: types.RateLimitTokenBucketFields
+}
+
+export interface BaseChainJSON {
+  remote: types.RemoteConfigJSON
+  inboundRateLimit: types.RateLimitTokenBucketJSON
+  outboundRateLimit: types.RateLimitTokenBucketJSON
+}
+
+export class BaseChain {
+  readonly remote: types.RemoteConfig
+  readonly inboundRateLimit: types.RateLimitTokenBucket
+  readonly outboundRateLimit: types.RateLimitTokenBucket
+
+  constructor(fields: BaseChainFields) {
+    this.remote = new types.RemoteConfig({ ...fields.remote })
+    this.inboundRateLimit = new types.RateLimitTokenBucket({
+      ...fields.inboundRateLimit,
+    })
+    this.outboundRateLimit = new types.RateLimitTokenBucket({
+      ...fields.outboundRateLimit,
+    })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.RemoteConfig.layout("remote"),
+        types.RateLimitTokenBucket.layout("inboundRateLimit"),
+        types.RateLimitTokenBucket.layout("outboundRateLimit"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new BaseChain({
+      remote: types.RemoteConfig.fromDecoded(obj.remote),
+      inboundRateLimit: types.RateLimitTokenBucket.fromDecoded(
+        obj.inboundRateLimit
+      ),
+      outboundRateLimit: types.RateLimitTokenBucket.fromDecoded(
+        obj.outboundRateLimit
+      ),
+    })
+  }
+
+  static toEncodable(fields: BaseChainFields) {
+    return {
+      remote: types.RemoteConfig.toEncodable(fields.remote),
+      inboundRateLimit: types.RateLimitTokenBucket.toEncodable(
+        fields.inboundRateLimit
+      ),
+      outboundRateLimit: types.RateLimitTokenBucket.toEncodable(
+        fields.outboundRateLimit
+      ),
+    }
+  }
+
+  toJSON(): BaseChainJSON {
+    return {
+      remote: this.remote.toJSON(),
+      inboundRateLimit: this.inboundRateLimit.toJSON(),
+      outboundRateLimit: this.outboundRateLimit.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: BaseChainJSON): BaseChain {
+    return new BaseChain({
+      remote: types.RemoteConfig.fromJSON(obj.remote),
+      inboundRateLimit: types.RateLimitTokenBucket.fromJSON(
+        obj.inboundRateLimit
+      ),
+      outboundRateLimit: types.RateLimitTokenBucket.fromJSON(
+        obj.outboundRateLimit
+      ),
+    })
+  }
+
+  toEncodable() {
+    return BaseChain.toEncodable(this)
+  }
+}

package/src/services/svm/bindings/types/BaseConfig.ts

@@ -0,0 +1,184 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface BaseConfigFields {
+  tokenProgram: PublicKey
+  mint: PublicKey
+  decimals: number
+  poolSigner: PublicKey
+  poolTokenAccount: PublicKey
+  owner: PublicKey
+  proposedOwner: PublicKey
+  rateLimitAdmin: PublicKey
+  routerOnrampAuthority: PublicKey
+  router: PublicKey
+  rebalancer: PublicKey
+  canAcceptLiquidity: boolean
+  listEnabled: boolean
+  allowList: Array<PublicKey>
+  rmnRemote: PublicKey
+}
+
+export interface BaseConfigJSON {
+  tokenProgram: string
+  mint: string
+  decimals: number
+  poolSigner: string
+  poolTokenAccount: string
+  owner: string
+  proposedOwner: string
+  rateLimitAdmin: string
+  routerOnrampAuthority: string
+  router: string
+  rebalancer: string
+  canAcceptLiquidity: boolean
+  listEnabled: boolean
+  allowList: Array<string>
+  rmnRemote: string
+}
+
+export class BaseConfig {
+  readonly tokenProgram: PublicKey
+  readonly mint: PublicKey
+  readonly decimals: number
+  readonly poolSigner: PublicKey
+  readonly poolTokenAccount: PublicKey
+  readonly owner: PublicKey
+  readonly proposedOwner: PublicKey
+  readonly rateLimitAdmin: PublicKey
+  readonly routerOnrampAuthority: PublicKey
+  readonly router: PublicKey
+  readonly rebalancer: PublicKey
+  readonly canAcceptLiquidity: boolean
+  readonly listEnabled: boolean
+  readonly allowList: Array<PublicKey>
+  readonly rmnRemote: PublicKey
+
+  constructor(fields: BaseConfigFields) {
+    this.tokenProgram = fields.tokenProgram
+    this.mint = fields.mint
+    this.decimals = fields.decimals
+    this.poolSigner = fields.poolSigner
+    this.poolTokenAccount = fields.poolTokenAccount
+    this.owner = fields.owner
+    this.proposedOwner = fields.proposedOwner
+    this.rateLimitAdmin = fields.rateLimitAdmin
+    this.routerOnrampAuthority = fields.routerOnrampAuthority
+    this.router = fields.router
+    this.rebalancer = fields.rebalancer
+    this.canAcceptLiquidity = fields.canAcceptLiquidity
+    this.listEnabled = fields.listEnabled
+    this.allowList = fields.allowList
+    this.rmnRemote = fields.rmnRemote
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("tokenProgram"),
+        borsh.publicKey("mint"),
+        borsh.u8("decimals"),
+        borsh.publicKey("poolSigner"),
+        borsh.publicKey("poolTokenAccount"),
+        borsh.publicKey("owner"),
+        borsh.publicKey("proposedOwner"),
+        borsh.publicKey("rateLimitAdmin"),
+        borsh.publicKey("routerOnrampAuthority"),
+        borsh.publicKey("router"),
+        borsh.publicKey("rebalancer"),
+        borsh.bool("canAcceptLiquidity"),
+        borsh.bool("listEnabled"),
+        borsh.vec(borsh.publicKey(), "allowList"),
+        borsh.publicKey("rmnRemote"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new BaseConfig({
+      tokenProgram: obj.tokenProgram,
+      mint: obj.mint,
+      decimals: obj.decimals,
+      poolSigner: obj.poolSigner,
+      poolTokenAccount: obj.poolTokenAccount,
+      owner: obj.owner,
+      proposedOwner: obj.proposedOwner,
+      rateLimitAdmin: obj.rateLimitAdmin,
+      routerOnrampAuthority: obj.routerOnrampAuthority,
+      router: obj.router,
+      rebalancer: obj.rebalancer,
+      canAcceptLiquidity: obj.canAcceptLiquidity,
+      listEnabled: obj.listEnabled,
+      allowList: obj.allowList,
+      rmnRemote: obj.rmnRemote,
+    })
+  }
+
+  static toEncodable(fields: BaseConfigFields) {
+    return {
+      tokenProgram: fields.tokenProgram,
+      mint: fields.mint,
+      decimals: fields.decimals,
+      poolSigner: fields.poolSigner,
+      poolTokenAccount: fields.poolTokenAccount,
+      owner: fields.owner,
+      proposedOwner: fields.proposedOwner,
+      rateLimitAdmin: fields.rateLimitAdmin,
+      routerOnrampAuthority: fields.routerOnrampAuthority,
+      router: fields.router,
+      rebalancer: fields.rebalancer,
+      canAcceptLiquidity: fields.canAcceptLiquidity,
+      listEnabled: fields.listEnabled,
+      allowList: fields.allowList,
+      rmnRemote: fields.rmnRemote,
+    }
+  }
+
+  toJSON(): BaseConfigJSON {
+    return {
+      tokenProgram: this.tokenProgram.toString(),
+      mint: this.mint.toString(),
+      decimals: this.decimals,
+      poolSigner: this.poolSigner.toString(),
+      poolTokenAccount: this.poolTokenAccount.toString(),
+      owner: this.owner.toString(),
+      proposedOwner: this.proposedOwner.toString(),
+      rateLimitAdmin: this.rateLimitAdmin.toString(),
+      routerOnrampAuthority: this.routerOnrampAuthority.toString(),
+      router: this.router.toString(),
+      rebalancer: this.rebalancer.toString(),
+      canAcceptLiquidity: this.canAcceptLiquidity,
+      listEnabled: this.listEnabled,
+      allowList: this.allowList.map((item) => item.toString()),
+      rmnRemote: this.rmnRemote.toString(),
+    }
+  }
+
+  static fromJSON(obj: BaseConfigJSON): BaseConfig {
+    return new BaseConfig({
+      tokenProgram: new PublicKey(obj.tokenProgram),
+      mint: new PublicKey(obj.mint),
+      decimals: obj.decimals,
+      poolSigner: new PublicKey(obj.poolSigner),
+      poolTokenAccount: new PublicKey(obj.poolTokenAccount),
+      owner: new PublicKey(obj.owner),
+      proposedOwner: new PublicKey(obj.proposedOwner),
+      rateLimitAdmin: new PublicKey(obj.rateLimitAdmin),
+      routerOnrampAuthority: new PublicKey(obj.routerOnrampAuthority),
+      router: new PublicKey(obj.router),
+      rebalancer: new PublicKey(obj.rebalancer),
+      canAcceptLiquidity: obj.canAcceptLiquidity,
+      listEnabled: obj.listEnabled,
+      allowList: obj.allowList.map((item) => new PublicKey(item)),
+      rmnRemote: new PublicKey(obj.rmnRemote),
+    })
+  }
+
+  toEncodable() {
+    return BaseConfig.toEncodable(this)
+  }
+}

package/src/services/svm/bindings/types/CodeVersion.ts

@@ -0,0 +1,88 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface DefaultJSON {
+  kind: "Default"
+}
+
+export class Default {
+  static readonly discriminator = 0
+  static readonly kind = "Default"
+  readonly discriminator = 0
+  readonly kind = "Default"
+
+  toJSON(): DefaultJSON {
+    return {
+      kind: "Default",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Default: {},
+    }
+  }
+}
+
+export interface V1JSON {
+  kind: "V1"
+}
+
+export class V1 {
+  static readonly discriminator = 1
+  static readonly kind = "V1"
+  readonly discriminator = 1
+  readonly kind = "V1"
+
+  toJSON(): V1JSON {
+    return {
+      kind: "V1",
+    }
+  }
+
+  toEncodable() {
+    return {
+      V1: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.CodeVersionKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("Default" in obj) {
+    return new Default()
+  }
+  if ("V1" in obj) {
+    return new V1()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(obj: types.CodeVersionJSON): types.CodeVersionKind {
+  switch (obj.kind) {
+    case "Default": {
+      return new Default()
+    }
+    case "V1": {
+      return new V1()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "Default"),
+    borsh.struct([], "V1"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

package/src/services/svm/bindings/types/CrossChainAmount.ts

@@ -0,0 +1,53 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface CrossChainAmountFields {
+  leBytes: Array<number>
+}
+
+export interface CrossChainAmountJSON {
+  leBytes: Array<number>
+}
+
+export class CrossChainAmount {
+  readonly leBytes: Array<number>
+
+  constructor(fields: CrossChainAmountFields) {
+    this.leBytes = fields.leBytes
+  }
+
+  static layout(property?: string) {
+    return borsh.struct([borsh.array(borsh.u8(), 32, "leBytes")], property)
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new CrossChainAmount({
+      leBytes: obj.leBytes,
+    })
+  }
+
+  static toEncodable(fields: CrossChainAmountFields) {
+    return {
+      leBytes: fields.leBytes,
+    }
+  }
+
+  toJSON(): CrossChainAmountJSON {
+    return {
+      leBytes: this.leBytes,
+    }
+  }
+
+  static fromJSON(obj: CrossChainAmountJSON): CrossChainAmount {
+    return new CrossChainAmount({
+      leBytes: obj.leBytes,
+    })
+  }
+
+  toEncodable() {
+    return CrossChainAmount.toEncodable(this)
+  }
+}

package/src/services/svm/bindings/types/DestChainConfig.ts

@@ -0,0 +1,76 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface DestChainConfigFields {
+  laneCodeVersion: types.CodeVersionKind
+  allowedSenders: Array<PublicKey>
+  allowListEnabled: boolean
+}
+
+export interface DestChainConfigJSON {
+  laneCodeVersion: types.CodeVersionJSON
+  allowedSenders: Array<string>
+  allowListEnabled: boolean
+}
+
+export class DestChainConfig {
+  readonly laneCodeVersion: types.CodeVersionKind
+  readonly allowedSenders: Array<PublicKey>
+  readonly allowListEnabled: boolean
+
+  constructor(fields: DestChainConfigFields) {
+    this.laneCodeVersion = fields.laneCodeVersion
+    this.allowedSenders = fields.allowedSenders
+    this.allowListEnabled = fields.allowListEnabled
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.CodeVersion.layout("laneCodeVersion"),
+        borsh.vec(borsh.publicKey(), "allowedSenders"),
+        borsh.bool("allowListEnabled"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new DestChainConfig({
+      laneCodeVersion: types.CodeVersion.fromDecoded(obj.laneCodeVersion),
+      allowedSenders: obj.allowedSenders,
+      allowListEnabled: obj.allowListEnabled,
+    })
+  }
+
+  static toEncodable(fields: DestChainConfigFields) {
+    return {
+      laneCodeVersion: fields.laneCodeVersion.toEncodable(),
+      allowedSenders: fields.allowedSenders,
+      allowListEnabled: fields.allowListEnabled,
+    }
+  }
+
+  toJSON(): DestChainConfigJSON {
+    return {
+      laneCodeVersion: this.laneCodeVersion.toJSON(),
+      allowedSenders: this.allowedSenders.map((item) => item.toString()),
+      allowListEnabled: this.allowListEnabled,
+    }
+  }
+
+  static fromJSON(obj: DestChainConfigJSON): DestChainConfig {
+    return new DestChainConfig({
+      laneCodeVersion: types.CodeVersion.fromJSON(obj.laneCodeVersion),
+      allowedSenders: obj.allowedSenders.map((item) => new PublicKey(item)),
+      allowListEnabled: obj.allowListEnabled,
+    })
+  }
+
+  toEncodable() {
+    return DestChainConfig.toEncodable(this)
+  }
+}

package/src/services/svm/bindings/types/DestChainState.ts

@@ -0,0 +1,76 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface DestChainStateFields {
+  sequenceNumber: BN
+  sequenceNumberToRestore: BN
+  restoreOnAction: types.RestoreOnActionKind
+}
+
+export interface DestChainStateJSON {
+  sequenceNumber: string
+  sequenceNumberToRestore: string
+  restoreOnAction: types.RestoreOnActionJSON
+}
+
+export class DestChainState {
+  readonly sequenceNumber: BN
+  readonly sequenceNumberToRestore: BN
+  readonly restoreOnAction: types.RestoreOnActionKind
+
+  constructor(fields: DestChainStateFields) {
+    this.sequenceNumber = fields.sequenceNumber
+    this.sequenceNumberToRestore = fields.sequenceNumberToRestore
+    this.restoreOnAction = fields.restoreOnAction
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.u64("sequenceNumber"),
+        borsh.u64("sequenceNumberToRestore"),
+        types.RestoreOnAction.layout("restoreOnAction"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new DestChainState({
+      sequenceNumber: obj.sequenceNumber,
+      sequenceNumberToRestore: obj.sequenceNumberToRestore,
+      restoreOnAction: types.RestoreOnAction.fromDecoded(obj.restoreOnAction),
+    })
+  }
+
+  static toEncodable(fields: DestChainStateFields) {
+    return {
+      sequenceNumber: fields.sequenceNumber,
+      sequenceNumberToRestore: fields.sequenceNumberToRestore,
+      restoreOnAction: fields.restoreOnAction.toEncodable(),
+    }
+  }
+
+  toJSON(): DestChainStateJSON {
+    return {
+      sequenceNumber: this.sequenceNumber.toString(),
+      sequenceNumberToRestore: this.sequenceNumberToRestore.toString(),
+      restoreOnAction: this.restoreOnAction.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: DestChainStateJSON): DestChainState {
+    return new DestChainState({
+      sequenceNumber: new BN(obj.sequenceNumber),
+      sequenceNumberToRestore: new BN(obj.sequenceNumberToRestore),
+      restoreOnAction: types.RestoreOnAction.fromJSON(obj.restoreOnAction),
+    })
+  }
+
+  toEncodable() {
+    return DestChainState.toEncodable(this)
+  }
+}

package/src/services/svm/bindings/types/GetFeeResult.ts

@@ -0,0 +1,72 @@
+import { PublicKey } from "@solana/web3.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh"
+
+export interface GetFeeResultFields {
+  amount: BN
+  juels: BN
+  token: PublicKey
+}
+
+export interface GetFeeResultJSON {
+  amount: string
+  juels: string
+  token: string
+}
+
+export class GetFeeResult {
+  readonly amount: BN
+  readonly juels: BN
+  readonly token: PublicKey
+
+  constructor(fields: GetFeeResultFields) {
+    this.amount = fields.amount
+    this.juels = fields.juels
+    this.token = fields.token
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.u64("amount"), borsh.u128("juels"), borsh.publicKey("token")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new GetFeeResult({
+      amount: obj.amount,
+      juels: obj.juels,
+      token: obj.token,
+    })
+  }
+
+  static toEncodable(fields: GetFeeResultFields) {
+    return {
+      amount: fields.amount,
+      juels: fields.juels,
+      token: fields.token,
+    }
+  }
+
+  toJSON(): GetFeeResultJSON {
+    return {
+      amount: this.amount.toString(),
+      juels: this.juels.toString(),
+      token: this.token.toString(),
+    }
+  }
+
+  static fromJSON(obj: GetFeeResultJSON): GetFeeResult {
+    return new GetFeeResult({
+      amount: new BN(obj.amount),
+      juels: new BN(obj.juels),
+      token: new PublicKey(obj.token),
+    })
+  }
+
+  toEncodable() {
+    return GetFeeResult.toEncodable(this)
+  }
+}