@xswap-link/sdk 0.10.8 → 0.10.9

package/src/services/svm/bindings/accounts/DestChain.ts

@@ -0,0 +1,113 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface DestChainFields {
+  version: number
+  chainSelector: BN
+  state: types.DestChainStateFields
+  config: types.DestChainConfigFields
+}
+
+export interface DestChainJSON {
+  version: number
+  chainSelector: string
+  state: types.DestChainStateJSON
+  config: types.DestChainConfigJSON
+}
+
+export class DestChain {
+  readonly version: number
+  readonly chainSelector: BN
+  readonly state: types.DestChainState
+  readonly config: types.DestChainConfig
+
+  static readonly discriminator = Buffer.from([
+    77, 18, 241, 132, 212, 54, 218, 16,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("version"),
+    borsh.u64("chainSelector"),
+    types.DestChainState.layout("state"),
+    types.DestChainConfig.layout("config"),
+  ])
+
+  constructor(fields: DestChainFields) {
+    this.version = fields.version
+    this.chainSelector = fields.chainSelector
+    this.state = new types.DestChainState({ ...fields.state })
+    this.config = new types.DestChainConfig({ ...fields.config })
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<DestChain | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<DestChain | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): DestChain {
+    if (!data.slice(0, 8).equals(DestChain.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = DestChain.layout.decode(data.slice(8))
+
+    return new DestChain({
+      version: dec.version,
+      chainSelector: dec.chainSelector,
+      state: types.DestChainState.fromDecoded(dec.state),
+      config: types.DestChainConfig.fromDecoded(dec.config),
+    })
+  }
+
+  toJSON(): DestChainJSON {
+    return {
+      version: this.version,
+      chainSelector: this.chainSelector.toString(),
+      state: this.state.toJSON(),
+      config: this.config.toJSON(),
+    }
+  }
+
+  static fromJSON(obj: DestChainJSON): DestChain {
+    return new DestChain({
+      version: obj.version,
+      chainSelector: new BN(obj.chainSelector),
+      state: types.DestChainState.fromJSON(obj.state),
+      config: types.DestChainConfig.fromJSON(obj.config),
+    })
+  }
+}

package/src/services/svm/bindings/accounts/Nonce.ts

@@ -0,0 +1,97 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface NonceFields {
+  version: number
+  counter: BN
+}
+
+export interface NonceJSON {
+  version: number
+  counter: string
+}
+
+export class Nonce {
+  readonly version: number
+  readonly counter: BN
+
+  static readonly discriminator = Buffer.from([
+    143, 197, 147, 95, 106, 165, 50, 43,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("version"),
+    borsh.u64("counter"),
+  ])
+
+  constructor(fields: NonceFields) {
+    this.version = fields.version
+    this.counter = fields.counter
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Nonce | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<Nonce | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): Nonce {
+    if (!data.slice(0, 8).equals(Nonce.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Nonce.layout.decode(data.slice(8))
+
+    return new Nonce({
+      version: dec.version,
+      counter: dec.counter,
+    })
+  }
+
+  toJSON(): NonceJSON {
+    return {
+      version: this.version,
+      counter: this.counter.toString(),
+    }
+  }
+
+  static fromJSON(obj: NonceJSON): Nonce {
+    return new Nonce({
+      version: obj.version,
+      counter: new BN(obj.counter),
+    })
+  }
+}

package/src/services/svm/bindings/accounts/index.ts

@@ -0,0 +1,15 @@
+export { AllowedOfframp } from "./AllowedOfframp";
+export type {
+  AllowedOfframpFields,
+  AllowedOfframpJSON,
+} from "./AllowedOfframp";
+export { Config } from "./Config";
+export type { ConfigFields, ConfigJSON } from "./Config";
+export { DestChain } from "./DestChain";
+export type { DestChainFields, DestChainJSON } from "./DestChain";
+export { Nonce } from "./Nonce";
+export type { NonceFields, NonceJSON } from "./Nonce";
+export {
+  TokenAdminRegistry as tokenAdminRegistry,
+  TokenAdminRegistryFields as tokenAdminRegistryFields,
+} from "./tokenAdminRegistry";

package/src/services/svm/bindings/accounts/tokenAdminRegistry.ts

@@ -0,0 +1,128 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
+
+export interface TokenAdminRegistryFields {
+  version: number
+  administrator: PublicKey
+  pendingAdministrator: PublicKey
+  lookupTable: PublicKey
+  writableIndexes: Array<BN>
+  mint: PublicKey
+}
+
+export interface TokenAdminRegistryJSON {
+  version: number
+  administrator: string
+  pendingAdministrator: string
+  lookupTable: string
+  writableIndexes: Array<string>
+  mint: string
+}
+
+export class TokenAdminRegistry {
+  readonly version: number
+  readonly administrator: PublicKey
+  readonly pendingAdministrator: PublicKey
+  readonly lookupTable: PublicKey
+  readonly writableIndexes: Array<BN>
+  readonly mint: PublicKey
+
+  static readonly discriminator = Buffer.from([
+    70, 92, 207, 200, 76, 17, 57, 114,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("version"),
+    borsh.publicKey("administrator"),
+    borsh.publicKey("pendingAdministrator"),
+    borsh.publicKey("lookupTable"),
+    borsh.array(borsh.u128(), 2, "writableIndexes"),
+    borsh.publicKey("mint"),
+  ])
+
+  constructor(fields: TokenAdminRegistryFields) {
+    this.version = fields.version
+    this.administrator = fields.administrator
+    this.pendingAdministrator = fields.pendingAdministrator
+    this.lookupTable = fields.lookupTable
+    this.writableIndexes = fields.writableIndexes
+    this.mint = fields.mint
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<TokenAdminRegistry | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<TokenAdminRegistry | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): TokenAdminRegistry {
+    if (!data.slice(0, 8).equals(TokenAdminRegistry.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = TokenAdminRegistry.layout.decode(data.slice(8))
+
+    return new TokenAdminRegistry({
+      version: dec.version,
+      administrator: dec.administrator,
+      pendingAdministrator: dec.pendingAdministrator,
+      lookupTable: dec.lookupTable,
+      writableIndexes: dec.writableIndexes,
+      mint: dec.mint,
+    })
+  }
+
+  toJSON(): TokenAdminRegistryJSON {
+    return {
+      version: this.version,
+      administrator: this.administrator.toString(),
+      pendingAdministrator: this.pendingAdministrator.toString(),
+      lookupTable: this.lookupTable.toString(),
+      writableIndexes: this.writableIndexes.map((item) => item.toString()),
+      mint: this.mint.toString(),
+    }
+  }
+
+  static fromJSON(obj: TokenAdminRegistryJSON): TokenAdminRegistry {
+    return new TokenAdminRegistry({
+      version: obj.version,
+      administrator: new PublicKey(obj.administrator),
+      pendingAdministrator: new PublicKey(obj.pendingAdministrator),
+      lookupTable: new PublicKey(obj.lookupTable),
+      writableIndexes: obj.writableIndexes.map((item) => new BN(item)),
+      mint: new PublicKey(obj.mint),
+    })
+  }
+}