@lucoadam/zebec-wormhole-sdk/dist/parser.js

This sdk can be use to transfer assets across chains and to interact with the Zebec's xchain bridge smart contracts for passing message from EVM chain to solana specially to utilize the features of Zebec Streaming and Zebec Multisig Streaming protocol.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.IsCancelSolStreamPayload = IsCancelSolStreamPayload;
exports.IsCancelTokenStreamPayload = IsCancelTokenStreamPayload;
exports.IsDirectTokenTransferPayload = IsDirectTokenTransferPayload;
exports.IsInstantSolPayload = IsInstantSolPayload;
exports.IsInstantTokenPayload = IsInstantTokenPayload;
exports.IsPauseSolStreamPayload = IsPauseSolStreamPayload;
exports.IsPauseTokenStreamPayload = IsPauseTokenStreamPayload;
exports.IsSolDepositPayload = IsSolDepositPayload;
exports.IsSolStreamPayload = IsSolStreamPayload;
exports.IsSolStreamUpdatePayload = IsSolStreamUpdatePayload;
exports.IsSolWithdrawPayload = IsSolWithdrawPayload;
exports.IsSolWithdrawStreamPayload = IsSolWithdrawStreamPayload;
exports.IsTokenDepositPayload = IsTokenDepositPayload;
exports.IsTokenStreamPayload = IsTokenStreamPayload;
exports.IsTokenStreamUpdatePayload = IsTokenStreamUpdatePayload;
exports.IsTokenWithdrawPayload = IsTokenWithdrawPayload;
exports.IsTokenWithdrawStreamPayload = IsTokenWithdrawStreamPayload;
exports.parseTokenWithdrawStreamPayload = exports.parseTokenWithdrawPayload = exports.parseTokenStreamUpdatePayload = exports.parseTokenStreamPayload = exports.parseTokenDepositPayload = exports.parseSolWithdrawStreamPayload = exports.parseSolWithdrawPayload = exports.parseSolStreamUpdatePayload = exports.parseSolStreamPayload = exports.parseSolDepositPayload = exports.parsePauseTokenStreamPayload = exports.parsePauseSolStreamPayload = exports.parseInstantTokenPayload = exports.parseInstantSolPayload = exports.parseDirectTokenTransferPayload = exports.parseCancelTokenStreamPayload = exports.parseCancelSolStreamPayload = exports.ZebecPayloadId = void 0;
exports.parseVaaTyped = parseVaaTyped;
exports.parseZebecPayload = parseZebecPayload;
exports.sizeof = void 0;
var _ethers = require("ethers");
var _wasm = require("@certusone/wormhole-sdk/lib/cjs/solana/wasm");
var _anchor = require("@project-serum/anchor");
var _errors = require("./utils/errors");
async function parseVaaTyped(signedVAA) {
  const {
    parse_vaa
  } = await (0, _wasm.importCoreWasm)();
  const parsedVAA = parse_vaa(signedVAA);
  return {
    timestamp: parsedVAA.timestamp,
    nonce: parsedVAA.nonce,
    emitterChain: parsedVAA.emitter_chain,
    emitterAddress: Uint8Array.from(parsedVAA.emitter_address),
    sequence: parsedVAA.sequence,
    // wormhole's 32 byte Hex Uint8Array
    consistencyLevel: parsedVAA.consistency_level,
    payload: Uint8Array.from(parsedVAA.payload)
  };
}
const sizeof = d => {
  return d === "u8" || d === "boolean" ? 1 : d === "u16" ? 2 : d === "u64" ? 8 : d === "u8[32]" ? 32 : d === "u256" ? 32 : 42;
};
exports.sizeof = sizeof;
let ZebecPayloadId;
exports.ZebecPayloadId = ZebecPayloadId;
(function (ZebecPayloadId) {
  ZebecPayloadId[ZebecPayloadId["SolStream"] = 1] = "SolStream";
  ZebecPayloadId[ZebecPayloadId["TokenStream"] = 2] = "TokenStream";
  ZebecPayloadId[ZebecPayloadId["SolWithdrawStream"] = 3] = "SolWithdrawStream";
  ZebecPayloadId[ZebecPayloadId["TokenWithdrawStream"] = 4] = "TokenWithdrawStream";
  ZebecPayloadId[ZebecPayloadId["DepositSol"] = 5] = "DepositSol";
  ZebecPayloadId[ZebecPayloadId["DepositToken"] = 6] = "DepositToken";
  ZebecPayloadId[ZebecPayloadId["PauseSolStream"] = 7] = "PauseSolStream";
  ZebecPayloadId[ZebecPayloadId["PauseTokenStream"] = 8] = "PauseTokenStream";
  ZebecPayloadId[ZebecPayloadId["WithdrawSol"] = 9] = "WithdrawSol";
  ZebecPayloadId[ZebecPayloadId["WithdrawToken"] = 10] = "WithdrawToken";
  ZebecPayloadId[ZebecPayloadId["InstantSol"] = 11] = "InstantSol";
  ZebecPayloadId[ZebecPayloadId["InstantToken"] = 12] = "InstantToken";
  ZebecPayloadId[ZebecPayloadId["SolStreamUpdate"] = 13] = "SolStreamUpdate";
  ZebecPayloadId[ZebecPayloadId["TokenStreamUpdate"] = 14] = "TokenStreamUpdate";
  ZebecPayloadId[ZebecPayloadId["CancelSolStream"] = 15] = "CancelSolStream";
  ZebecPayloadId[ZebecPayloadId["CancelTokenStream"] = 16] = "CancelTokenStream";
  ZebecPayloadId[ZebecPayloadId["DirectTokenTransfer"] = 17] = "DirectTokenTransfer";
})(ZebecPayloadId || (exports.ZebecPayloadId = ZebecPayloadId = {}));
const parseSolStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    startTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    endTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    canCancel: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    canUpdate: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt()
  };
  return payload;
};
exports.parseSolStreamPayload = parseSolStreamPayload;
function IsSolStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.SolStream && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array && typeof payload.startTime == "bigint" && typeof payload.endTime == "bigint" && typeof payload.canCancel == "bigint" && typeof payload.canUpdate == "bigint";
}
const parseTokenStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    startTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    endTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    canCancel: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    canUpdate: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseTokenStreamPayload = parseTokenStreamPayload;
function IsTokenStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.TokenStream && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array && typeof payload.startTime == "bigint" && typeof payload.endTime == "bigint" && typeof payload.canCancel == "bigint" && typeof payload.canUpdate == "bigint" && payload.tokenMint instanceof Uint8Array;
}
const parseSolWithdrawStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    withdrawer: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseSolWithdrawStreamPayload = parseSolWithdrawStreamPayload;
function IsSolWithdrawStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.SolWithdrawStream && typeof payload.targetChain == "number" && payload.withdrawer instanceof Uint8Array;
}
const parseTokenWithdrawStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    withdrawer: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    dataAccount: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseTokenWithdrawStreamPayload = parseTokenWithdrawStreamPayload;
function IsTokenWithdrawStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.TokenWithdrawStream && typeof payload.targetChain == "number" && payload.withdrawer instanceof Uint8Array && payload.tokenMint instanceof Uint8Array && payload.sender instanceof Uint8Array && payload.dataAccount instanceof Uint8Array;
}
const parseSolDepositPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseSolDepositPayload = parseSolDepositPayload;
function IsSolDepositPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.DepositSol && typeof payload.amount == "bigint" && typeof payload.targetChain == "number" && payload.sender instanceof Uint8Array;
}
const parseTokenDepositPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseTokenDepositPayload = parseTokenDepositPayload;
function IsTokenDepositPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.DepositToken && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && payload.sender instanceof Uint8Array && payload.tokenMint instanceof Uint8Array;
}
const parsePauseSolStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parsePauseSolStreamPayload = parsePauseSolStreamPayload;
function IsPauseSolStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.PauseSolStream && payload.sender instanceof Uint8Array && typeof payload.targetChain == "number";
}
const parsePauseTokenStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    dataAccount: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  console.log("tokenMint:", new _anchor.web3.PublicKey(payload.tokenMint));
  return payload;
};
exports.parsePauseTokenStreamPayload = parsePauseTokenStreamPayload;
function IsPauseTokenStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.PauseTokenStream && payload.sender instanceof Uint8Array && typeof payload.targetChain == "number" && payload.tokenMint instanceof Uint8Array && payload.recipient instanceof Uint8Array && payload.dataAccount instanceof Uint8Array;
}
function IsSolWithdrawPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.WithdrawSol && typeof payload.id == "bigint" && payload.withdrawer instanceof Uint8Array && typeof payload.targetChain == "number";
}
const parseSolWithdrawPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    withdrawer: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseSolWithdrawPayload = parseSolWithdrawPayload;
const parseTokenWithdrawPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    withdrawer: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  console.log("id:", payload.id);
  console.log("amount:", payload.amount);
  console.log("targetChain:", payload.targetChain);
  console.log("withdrawer:", payload.withdrawer);
  console.log("tokenMint:", new _anchor.web3.PublicKey(payload.tokenMint).toString());
  return payload;
};
exports.parseTokenWithdrawPayload = parseTokenWithdrawPayload;
function IsTokenWithdrawPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.WithdrawToken && typeof payload.amount == "bigint" && payload.withdrawer instanceof Uint8Array && typeof payload.targetChain == "number" && payload.tokenMint instanceof Uint8Array;
}
const parseInstantSolPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseInstantSolPayload = parseInstantSolPayload;
function IsInstantSolPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.InstantSol && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array && typeof payload.targetChain == "number" && typeof payload.amount == "bigint";
}
const parseInstantTokenPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseInstantTokenPayload = parseInstantTokenPayload;
function IsInstantTokenPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.InstantToken && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && payload.tokenMint instanceof Uint8Array;
}
const parseSolStreamUpdatePayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    startTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    endTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseSolStreamUpdatePayload = parseSolStreamUpdatePayload;
function IsSolStreamUpdatePayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.SolStreamUpdate && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && typeof payload.startTime == "bigint" && typeof payload.endTime == "bigint" && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array;
}
const parseTokenStreamUpdatePayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    startTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    endTime: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    dataAccount: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  console.log("tokenMint:", new _anchor.web3.PublicKey(payload.tokenMint).toString());
  return payload;
};
exports.parseTokenStreamUpdatePayload = parseTokenStreamUpdatePayload;
function IsTokenStreamUpdatePayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.TokenStreamUpdate && typeof payload.targetChain == "number" && typeof payload.amount == "bigint" && typeof payload.startTime == "bigint" && typeof payload.endTime == "bigint" && payload.sender instanceof Uint8Array && payload.recipient instanceof Uint8Array && payload.tokenMint instanceof Uint8Array && payload.dataAccount instanceof Uint8Array;
}
function IsCancelSolStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.CancelSolStream && typeof payload.targetChain == "number" && payload.sender instanceof Uint8Array;
}
const parseCancelSolStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseCancelSolStreamPayload = parseCancelSolStreamPayload;
const parseCancelTokenStreamPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    recipient: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    dataAccount: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseCancelTokenStreamPayload = parseCancelTokenStreamPayload;
function IsCancelTokenStreamPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.CancelTokenStream && typeof payload.targetChain == "number" && payload.sender instanceof Uint8Array && payload.tokenMint instanceof Uint8Array && payload.recipient instanceof Uint8Array && payload.dataAccount instanceof Uint8Array;
}

//TODO:: fill this

const parseDirectTokenTransferPayload = arr => {
  console.log("payload buffer length:", arr.length);
  let i = 0;
  const payload = {
    id: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u8"))).toNumber(),
    amount: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u64"))).toBigInt(),
    targetChain: _ethers.BigNumber.from(arr.subarray(i, i += sizeof("u256"))).toNumber(),
    sender: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    tokenMint: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]"))),
    receiver: Uint8Array.from(arr.subarray(i, i += sizeof("u8[32]")))
  };
  return payload;
};
exports.parseDirectTokenTransferPayload = parseDirectTokenTransferPayload;
function IsDirectTokenTransferPayload(payload) {
  return typeof payload.id == "number" && payload.id === ZebecPayloadId.DirectTokenTransfer && typeof payload.targetChain == "number" && payload.sender instanceof Uint8Array && payload.tokenMint instanceof Uint8Array && payload.receiver instanceof Uint8Array && typeof payload.amount == "bigint";
}
/** Parse the VAA and return the typed payload */
function parseZebecPayload(payloadBuf) {
  try {
    let parsedPayload;
    const payloadId = payloadBuf[0];
    console.log("payloadId:", payloadId);
    switch (payloadId) {
      case ZebecPayloadId.SolStream:
        parsedPayload = parseSolStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.TokenStream:
        parsedPayload = parseTokenStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.SolWithdrawStream:
        parsedPayload = parseSolWithdrawStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.TokenWithdrawStream:
        parsedPayload = parseTokenWithdrawStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.DepositSol:
        parsedPayload = parseSolDepositPayload(payloadBuf);
        break;
      case ZebecPayloadId.DepositToken:
        parsedPayload = parseTokenDepositPayload(payloadBuf);
        break;
      case ZebecPayloadId.PauseSolStream:
        parsedPayload = parsePauseSolStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.PauseTokenStream:
        parsedPayload = parsePauseTokenStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.WithdrawSol:
        parsedPayload = parseSolWithdrawPayload(payloadBuf);
        break;
      case ZebecPayloadId.WithdrawToken:
        parsedPayload = parseTokenWithdrawPayload(payloadBuf);
        break;
      case ZebecPayloadId.InstantSol:
        parsedPayload = parseInstantSolPayload(payloadBuf);
        break;
      case ZebecPayloadId.InstantToken:
        parsedPayload = parseInstantTokenPayload(payloadBuf);
        break;
      case ZebecPayloadId.SolStreamUpdate:
        parsedPayload = parseSolStreamUpdatePayload(payloadBuf);
        break;
      case ZebecPayloadId.TokenStreamUpdate:
        parsedPayload = parseTokenStreamUpdatePayload(payloadBuf);
        break;
      case ZebecPayloadId.CancelSolStream:
        parsedPayload = parseCancelSolStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.CancelTokenStream:
        parsedPayload = parseCancelTokenStreamPayload(payloadBuf);
        break;
      case ZebecPayloadId.DirectTokenTransfer:
        parsedPayload = parseDirectTokenTransferPayload(payloadBuf);
    }
    return parsedPayload;
  } catch (e) {
    throw new _errors.PayloadParseError(e instanceof Error ? e.message : "Unknown payload parse error");
  }
}
//# sourceMappingURL=parser.js.map