@xswap-link/sdk 0.10.8 → 0.10.10

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

@@ -0,0 +1,86 @@
+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 RemoteConfigFields {
+  poolAddresses: Array<types.RemoteAddressFields>
+  tokenAddress: types.RemoteAddressFields
+  decimals: number
+}
+
+export interface RemoteConfigJSON {
+  poolAddresses: Array<types.RemoteAddressJSON>
+  tokenAddress: types.RemoteAddressJSON
+  decimals: number
+}
+
+export class RemoteConfig {
+  readonly poolAddresses: Array<types.RemoteAddress>
+  readonly tokenAddress: types.RemoteAddress
+  readonly decimals: number
+
+  constructor(fields: RemoteConfigFields) {
+    this.poolAddresses = fields.poolAddresses.map(
+      (item) => new types.RemoteAddress({ ...item })
+    )
+    this.tokenAddress = new types.RemoteAddress({ ...fields.tokenAddress })
+    this.decimals = fields.decimals
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.vec(types.RemoteAddress.layout(), "poolAddresses"),
+        types.RemoteAddress.layout("tokenAddress"),
+        borsh.u8("decimals"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new RemoteConfig({
+      poolAddresses: obj.poolAddresses.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.RemoteAddress.fromDecoded(item)
+      ),
+      tokenAddress: types.RemoteAddress.fromDecoded(obj.tokenAddress),
+      decimals: obj.decimals,
+    })
+  }
+
+  static toEncodable(fields: RemoteConfigFields) {
+    return {
+      poolAddresses: fields.poolAddresses.map((item) =>
+        types.RemoteAddress.toEncodable(item)
+      ),
+      tokenAddress: types.RemoteAddress.toEncodable(fields.tokenAddress),
+      decimals: fields.decimals,
+    }
+  }
+
+  toJSON(): RemoteConfigJSON {
+    return {
+      poolAddresses: this.poolAddresses.map((item) => item.toJSON()),
+      tokenAddress: this.tokenAddress.toJSON(),
+      decimals: this.decimals,
+    }
+  }
+
+  static fromJSON(obj: RemoteConfigJSON): RemoteConfig {
+    return new RemoteConfig({
+      poolAddresses: obj.poolAddresses.map((item) =>
+        types.RemoteAddress.fromJSON(item)
+      ),
+      tokenAddress: types.RemoteAddress.fromJSON(obj.tokenAddress),
+      decimals: obj.decimals,
+    })
+  }
+
+  toEncodable() {
+    return RemoteConfig.toEncodable(this)
+  }
+}

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

@@ -0,0 +1,120 @@
+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 NoneJSON {
+  kind: "None"
+}
+
+export class None {
+  static readonly discriminator = 0
+  static readonly kind = "None"
+  readonly discriminator = 0
+  readonly kind = "None"
+
+  toJSON(): NoneJSON {
+    return {
+      kind: "None",
+    }
+  }
+
+  toEncodable() {
+    return {
+      None: {},
+    }
+  }
+}
+
+export interface UpgradeJSON {
+  kind: "Upgrade"
+}
+
+export class Upgrade {
+  static readonly discriminator = 1
+  static readonly kind = "Upgrade"
+  readonly discriminator = 1
+  readonly kind = "Upgrade"
+
+  toJSON(): UpgradeJSON {
+    return {
+      kind: "Upgrade",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Upgrade: {},
+    }
+  }
+}
+
+export interface RollbackJSON {
+  kind: "Rollback"
+}
+
+export class Rollback {
+  static readonly discriminator = 2
+  static readonly kind = "Rollback"
+  readonly discriminator = 2
+  readonly kind = "Rollback"
+
+  toJSON(): RollbackJSON {
+    return {
+      kind: "Rollback",
+    }
+  }
+
+  toEncodable() {
+    return {
+      Rollback: {},
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.RestoreOnActionKind {
+  if (typeof obj !== "object") {
+    throw new Error("Invalid enum object")
+  }
+
+  if ("None" in obj) {
+    return new None()
+  }
+  if ("Upgrade" in obj) {
+    return new Upgrade()
+  }
+  if ("Rollback" in obj) {
+    return new Rollback()
+  }
+
+  throw new Error("Invalid enum object")
+}
+
+export function fromJSON(
+  obj: types.RestoreOnActionJSON
+): types.RestoreOnActionKind {
+  switch (obj.kind) {
+    case "None": {
+      return new None()
+    }
+    case "Upgrade": {
+      return new Upgrade()
+    }
+    case "Rollback": {
+      return new Rollback()
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([
+    borsh.struct([], "None"),
+    borsh.struct([], "Upgrade"),
+    borsh.struct([], "Rollback"),
+  ])
+  if (property !== undefined) {
+    return ret.replicate(property)
+  }
+  return ret
+}

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

@@ -0,0 +1,128 @@
+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 SVM2AnyMessageFields {
+  receiver: Uint8Array
+  data: Uint8Array
+  tokenAmounts: Array<types.SVMTokenAmountFields>
+  feeToken: PublicKey
+  extraArgs: Uint8Array
+}
+
+export interface SVM2AnyMessageJSON {
+  receiver: Array<number>
+  data: Array<number>
+  tokenAmounts: Array<types.SVMTokenAmountJSON>
+  feeToken: string
+  extraArgs: Array<number>
+}
+
+export class SVM2AnyMessage {
+  readonly receiver: Uint8Array
+  readonly data: Uint8Array
+  readonly tokenAmounts: Array<types.SVMTokenAmount>
+  readonly feeToken: PublicKey
+  readonly extraArgs: Uint8Array
+
+  constructor(fields: SVM2AnyMessageFields) {
+    this.receiver = fields.receiver
+    this.data = fields.data
+    this.tokenAmounts = fields.tokenAmounts.map(
+      (item) => new types.SVMTokenAmount({ ...item })
+    )
+    this.feeToken = fields.feeToken
+    this.extraArgs = fields.extraArgs
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.vecU8("receiver"),
+        borsh.vecU8("data"),
+        borsh.vec(types.SVMTokenAmount.layout(), "tokenAmounts"),
+        borsh.publicKey("feeToken"),
+        borsh.vecU8("extraArgs"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SVM2AnyMessage({
+      receiver: new Uint8Array(
+        obj.receiver.buffer,
+        obj.receiver.byteOffset,
+        obj.receiver.length
+      ),
+      data: new Uint8Array(
+        obj.data.buffer,
+        obj.data.byteOffset,
+        obj.data.length
+      ),
+      tokenAmounts: obj.tokenAmounts.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.SVMTokenAmount.fromDecoded(item)
+      ),
+      feeToken: obj.feeToken,
+      extraArgs: new Uint8Array(
+        obj.extraArgs.buffer,
+        obj.extraArgs.byteOffset,
+        obj.extraArgs.length
+      ),
+    })
+  }
+
+  static toEncodable(fields: SVM2AnyMessageFields) {
+    return {
+      receiver: Buffer.from(
+        fields.receiver.buffer,
+        fields.receiver.byteOffset,
+        fields.receiver.length
+      ),
+      data: Buffer.from(
+        fields.data.buffer,
+        fields.data.byteOffset,
+        fields.data.length
+      ),
+      tokenAmounts: fields.tokenAmounts.map((item) =>
+        types.SVMTokenAmount.toEncodable(item)
+      ),
+      feeToken: fields.feeToken,
+      extraArgs: Buffer.from(
+        fields.extraArgs.buffer,
+        fields.extraArgs.byteOffset,
+        fields.extraArgs.length
+      ),
+    }
+  }
+
+  toJSON(): SVM2AnyMessageJSON {
+    return {
+      receiver: Array.from(this.receiver.values()),
+      data: Array.from(this.data.values()),
+      tokenAmounts: this.tokenAmounts.map((item) => item.toJSON()),
+      feeToken: this.feeToken.toString(),
+      extraArgs: Array.from(this.extraArgs.values()),
+    }
+  }
+
+  static fromJSON(obj: SVM2AnyMessageJSON): SVM2AnyMessage {
+    return new SVM2AnyMessage({
+      receiver: Uint8Array.from(obj.receiver),
+      data: Uint8Array.from(obj.data),
+      tokenAmounts: obj.tokenAmounts.map((item) =>
+        types.SVMTokenAmount.fromJSON(item)
+      ),
+      feeToken: new PublicKey(obj.feeToken),
+      extraArgs: Uint8Array.from(obj.extraArgs),
+    })
+  }
+
+  toEncodable() {
+    return SVM2AnyMessage.toEncodable(this)
+  }
+}

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

@@ -0,0 +1,166 @@
+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 SVM2AnyRampMessageFields {
+  header: types.RampMessageHeaderFields
+  sender: PublicKey
+  data: Uint8Array
+  receiver: Uint8Array
+  extraArgs: Uint8Array
+  feeToken: PublicKey
+  tokenAmounts: Array<types.SVM2AnyTokenTransferFields>
+  feeTokenAmount: types.CrossChainAmountFields
+  feeValueJuels: types.CrossChainAmountFields
+}
+
+export interface SVM2AnyRampMessageJSON {
+  header: types.RampMessageHeaderJSON
+  sender: string
+  data: Array<number>
+  receiver: Array<number>
+  extraArgs: Array<number>
+  feeToken: string
+  tokenAmounts: Array<types.SVM2AnyTokenTransferJSON>
+  feeTokenAmount: types.CrossChainAmountJSON
+  feeValueJuels: types.CrossChainAmountJSON
+}
+
+export class SVM2AnyRampMessage {
+  readonly header: types.RampMessageHeader
+  readonly sender: PublicKey
+  readonly data: Uint8Array
+  readonly receiver: Uint8Array
+  readonly extraArgs: Uint8Array
+  readonly feeToken: PublicKey
+  readonly tokenAmounts: Array<types.SVM2AnyTokenTransfer>
+  readonly feeTokenAmount: types.CrossChainAmount
+  readonly feeValueJuels: types.CrossChainAmount
+
+  constructor(fields: SVM2AnyRampMessageFields) {
+    this.header = new types.RampMessageHeader({ ...fields.header })
+    this.sender = fields.sender
+    this.data = fields.data
+    this.receiver = fields.receiver
+    this.extraArgs = fields.extraArgs
+    this.feeToken = fields.feeToken
+    this.tokenAmounts = fields.tokenAmounts.map(
+      (item) => new types.SVM2AnyTokenTransfer({ ...item })
+    )
+    this.feeTokenAmount = new types.CrossChainAmount({
+      ...fields.feeTokenAmount,
+    })
+    this.feeValueJuels = new types.CrossChainAmount({ ...fields.feeValueJuels })
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        types.RampMessageHeader.layout("header"),
+        borsh.publicKey("sender"),
+        borsh.vecU8("data"),
+        borsh.vecU8("receiver"),
+        borsh.vecU8("extraArgs"),
+        borsh.publicKey("feeToken"),
+        borsh.vec(types.SVM2AnyTokenTransfer.layout(), "tokenAmounts"),
+        types.CrossChainAmount.layout("feeTokenAmount"),
+        types.CrossChainAmount.layout("feeValueJuels"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SVM2AnyRampMessage({
+      header: types.RampMessageHeader.fromDecoded(obj.header),
+      sender: obj.sender,
+      data: new Uint8Array(
+        obj.data.buffer,
+        obj.data.byteOffset,
+        obj.data.length
+      ),
+      receiver: new Uint8Array(
+        obj.receiver.buffer,
+        obj.receiver.byteOffset,
+        obj.receiver.length
+      ),
+      extraArgs: new Uint8Array(
+        obj.extraArgs.buffer,
+        obj.extraArgs.byteOffset,
+        obj.extraArgs.length
+      ),
+      feeToken: obj.feeToken,
+      tokenAmounts: obj.tokenAmounts.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.SVM2AnyTokenTransfer.fromDecoded(item)
+      ),
+      feeTokenAmount: types.CrossChainAmount.fromDecoded(obj.feeTokenAmount),
+      feeValueJuels: types.CrossChainAmount.fromDecoded(obj.feeValueJuels),
+    })
+  }
+
+  static toEncodable(fields: SVM2AnyRampMessageFields) {
+    return {
+      header: types.RampMessageHeader.toEncodable(fields.header),
+      sender: fields.sender,
+      data: Buffer.from(
+        fields.data.buffer,
+        fields.data.byteOffset,
+        fields.data.length
+      ),
+      receiver: Buffer.from(
+        fields.receiver.buffer,
+        fields.receiver.byteOffset,
+        fields.receiver.length
+      ),
+      extraArgs: Buffer.from(
+        fields.extraArgs.buffer,
+        fields.extraArgs.byteOffset,
+        fields.extraArgs.length
+      ),
+      feeToken: fields.feeToken,
+      tokenAmounts: fields.tokenAmounts.map((item) =>
+        types.SVM2AnyTokenTransfer.toEncodable(item)
+      ),
+      feeTokenAmount: types.CrossChainAmount.toEncodable(fields.feeTokenAmount),
+      feeValueJuels: types.CrossChainAmount.toEncodable(fields.feeValueJuels),
+    }
+  }
+
+  toJSON(): SVM2AnyRampMessageJSON {
+    return {
+      header: this.header.toJSON(),
+      sender: this.sender.toString(),
+      data: Array.from(this.data.values()),
+      receiver: Array.from(this.receiver.values()),
+      extraArgs: Array.from(this.extraArgs.values()),
+      feeToken: this.feeToken.toString(),
+      tokenAmounts: this.tokenAmounts.map((item) => item.toJSON()),
+      feeTokenAmount: this.feeTokenAmount.toJSON(),
+      feeValueJuels: this.feeValueJuels.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: SVM2AnyRampMessageJSON): SVM2AnyRampMessage {
+    return new SVM2AnyRampMessage({
+      header: types.RampMessageHeader.fromJSON(obj.header),
+      sender: new PublicKey(obj.sender),
+      data: Uint8Array.from(obj.data),
+      receiver: Uint8Array.from(obj.receiver),
+      extraArgs: Uint8Array.from(obj.extraArgs),
+      feeToken: new PublicKey(obj.feeToken),
+      tokenAmounts: obj.tokenAmounts.map((item) =>
+        types.SVM2AnyTokenTransfer.fromJSON(item)
+      ),
+      feeTokenAmount: types.CrossChainAmount.fromJSON(obj.feeTokenAmount),
+      feeValueJuels: types.CrossChainAmount.fromJSON(obj.feeValueJuels),
+    })
+  }
+
+  toEncodable() {
+    return SVM2AnyRampMessage.toEncodable(this)
+  }
+}

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

@@ -0,0 +1,118 @@
+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 SVM2AnyTokenTransferFields {
+  sourcePoolAddress: PublicKey
+  destTokenAddress: Uint8Array
+  extraData: Uint8Array
+  amount: types.CrossChainAmountFields
+  destExecData: Uint8Array
+}
+
+export interface SVM2AnyTokenTransferJSON {
+  sourcePoolAddress: string
+  destTokenAddress: Array<number>
+  extraData: Array<number>
+  amount: types.CrossChainAmountJSON
+  destExecData: Array<number>
+}
+
+export class SVM2AnyTokenTransfer {
+  readonly sourcePoolAddress: PublicKey
+  readonly destTokenAddress: Uint8Array
+  readonly extraData: Uint8Array
+  readonly amount: types.CrossChainAmount
+  readonly destExecData: Uint8Array
+
+  constructor(fields: SVM2AnyTokenTransferFields) {
+    this.sourcePoolAddress = fields.sourcePoolAddress
+    this.destTokenAddress = fields.destTokenAddress
+    this.extraData = fields.extraData
+    this.amount = new types.CrossChainAmount({ ...fields.amount })
+    this.destExecData = fields.destExecData
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.publicKey("sourcePoolAddress"),
+        borsh.vecU8("destTokenAddress"),
+        borsh.vecU8("extraData"),
+        types.CrossChainAmount.layout("amount"),
+        borsh.vecU8("destExecData"),
+      ],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SVM2AnyTokenTransfer({
+      sourcePoolAddress: obj.sourcePoolAddress,
+      destTokenAddress: new Uint8Array(
+        obj.destTokenAddress.buffer,
+        obj.destTokenAddress.byteOffset,
+        obj.destTokenAddress.length
+      ),
+      extraData: new Uint8Array(
+        obj.extraData.buffer,
+        obj.extraData.byteOffset,
+        obj.extraData.length
+      ),
+      amount: types.CrossChainAmount.fromDecoded(obj.amount),
+      destExecData: new Uint8Array(
+        obj.destExecData.buffer,
+        obj.destExecData.byteOffset,
+        obj.destExecData.length
+      ),
+    })
+  }
+
+  static toEncodable(fields: SVM2AnyTokenTransferFields) {
+    return {
+      sourcePoolAddress: fields.sourcePoolAddress,
+      destTokenAddress: Buffer.from(
+        fields.destTokenAddress.buffer,
+        fields.destTokenAddress.byteOffset,
+        fields.destTokenAddress.length
+      ),
+      extraData: Buffer.from(
+        fields.extraData.buffer,
+        fields.extraData.byteOffset,
+        fields.extraData.length
+      ),
+      amount: types.CrossChainAmount.toEncodable(fields.amount),
+      destExecData: Buffer.from(
+        fields.destExecData.buffer,
+        fields.destExecData.byteOffset,
+        fields.destExecData.length
+      ),
+    }
+  }
+
+  toJSON(): SVM2AnyTokenTransferJSON {
+    return {
+      sourcePoolAddress: this.sourcePoolAddress.toString(),
+      destTokenAddress: Array.from(this.destTokenAddress.values()),
+      extraData: Array.from(this.extraData.values()),
+      amount: this.amount.toJSON(),
+      destExecData: Array.from(this.destExecData.values()),
+    }
+  }
+
+  static fromJSON(obj: SVM2AnyTokenTransferJSON): SVM2AnyTokenTransfer {
+    return new SVM2AnyTokenTransfer({
+      sourcePoolAddress: new PublicKey(obj.sourcePoolAddress),
+      destTokenAddress: Uint8Array.from(obj.destTokenAddress),
+      extraData: Uint8Array.from(obj.extraData),
+      amount: types.CrossChainAmount.fromJSON(obj.amount),
+      destExecData: Uint8Array.from(obj.destExecData),
+    })
+  }
+
+  toEncodable() {
+    return SVM2AnyTokenTransfer.toEncodable(this)
+  }
+}

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

@@ -0,0 +1,64 @@
+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 SVMTokenAmountFields {
+  token: PublicKey
+  amount: BN
+}
+
+export interface SVMTokenAmountJSON {
+  token: string
+  amount: string
+}
+
+export class SVMTokenAmount {
+  readonly token: PublicKey
+  readonly amount: BN
+
+  constructor(fields: SVMTokenAmountFields) {
+    this.token = fields.token
+    this.amount = fields.amount
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [borsh.publicKey("token"), borsh.u64("amount")],
+      property
+    )
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new SVMTokenAmount({
+      token: obj.token,
+      amount: obj.amount,
+    })
+  }
+
+  static toEncodable(fields: SVMTokenAmountFields) {
+    return {
+      token: fields.token,
+      amount: fields.amount,
+    }
+  }
+
+  toJSON(): SVMTokenAmountJSON {
+    return {
+      token: this.token.toString(),
+      amount: this.amount.toString(),
+    }
+  }
+
+  static fromJSON(obj: SVMTokenAmountJSON): SVMTokenAmount {
+    return new SVMTokenAmount({
+      token: new PublicKey(obj.token),
+      amount: new BN(obj.amount),
+    })
+  }
+
+  toEncodable() {
+    return SVMTokenAmount.toEncodable(this)
+  }
+}