@project-serum/anchor#utils TypeScript Examples

findReplicaMintAddress = async ({
  programId = QUARRY_ADDRESSES.MergeMine,
  primaryMint,
}: {
  programId?: PublicKey;
  primaryMint: PublicKey;
}): Promise<[PublicKey, number]> => {
  const [pool] = await findPoolAddress({ programId, primaryMint });
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("ReplicaMint"), pool.toBuffer()],
    programId
  );
}

/**
   * Gets the address of a wrapped token.
   * @param programID
   * @param underlyingMint
   * @param decimals
   * @returns
   */
  static getAddressSync(
    underlyingMint: PublicKey,
    decimals: number
  ): PublicKey {
    return getProgramAddress(
      [
        utils.bytes.utf8.encode("anchor"), // b"anchor".
        underlyingMint.toBytes(),
        Buffer.from([decimals]),
      ],
      SABER_ADDRESSES.AddDecimals
    );
  }

/**
   * Gets the address and nonce of a wrapped token.
   * @param programID
   * @param underlyingMint
   * @param decimals
   * @returns
   */
  static async getAddressAndNonce(
    programID: PublicKey,
    underlyingMint: PublicKey,
    decimals: number
  ): Promise<[PublicKey, number]> {
    return await PublicKey.findProgramAddress(
      [
        Buffer.from(utils.bytes.utf8.encode("anchor")), // b"anchor".
        underlyingMint.toBytes(),
        Buffer.from([decimals]),
      ],
      programID
    );
  }

findRedeemerKey = async ({
  iouMint,
  redemptionMint,
}: {
  iouMint: PublicKey;
  redemptionMint: PublicKey;
}): Promise<[PublicKey, number]> => {
  return PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("Redeemer"),
      iouMint.toBytes(),
      redemptionMint.toBytes(),
    ],
    SABER_ADDRESSES.Redeemer
  );
}

public settleFunds(
    openOrders: PublicKey,
    owner: PublicKey,
    baseWallet: PublicKey,
    quoteWallet: PublicKey,
    referrerQuoteWallet: PublicKey,
  ): TransactionInstruction {
    const ix = DexInstructions.settleFunds({
      market: this._market.address,
      openOrders,
      owner,
      baseVault: this._market.decoded.baseVault,
      quoteVault: this._market.decoded.quoteVault,
      baseWallet,
      quoteWallet,
      vaultSigner: utils.publicKey.createProgramAddressSync(
        [
          this._market.address.toBuffer(),
          this._market.decoded.vaultSignerNonce.toArrayLike(Buffer, 'le', 8),
        ],
        this._dexProgramId,
      ),
      programId: this._proxyProgramId,
      referrerQuoteWallet,
    });
    this._middlewares.forEach((mw) => mw.settleFunds(ix));
    return this.proxy(ix);
  }

generateSunnyPoolAddress = async ({
  quarry,
}: {
  quarry: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("SunnyQuarryPool"),
      SUNNY_CREATOR_KEY.toBuffer(),
      quarry.toBuffer(),
    ],
    SUNNY_PROGRAM
  );
}

generateSunnyVaultAddress = async ({
  pool,
  owner,
}: {
  pool: PublicKey;
  owner: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("SunnyQuarryVault"),
      pool.toBuffer(),
      owner.toBuffer(),
    ],
    SUNNY_PROGRAM
  );
}

generateArrowAddress = (
  mint: PublicKey,
  programID: PublicKey = ARROW_ADDRESSES.ArrowSunny
): Promise<[PublicKey, number]> => {
  return PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("arrow"), mint.toBuffer()],
    programID
  );
}

findTokenRecordAddress = async (
  authorityKey: PublicKey,
  electorateKey: PublicKey
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("SimpleTokenRecord"),
      authorityKey.toBuffer(),
      electorateKey.toBuffer(),
    ],
    TRIBECA_ADDRESSES.SimpleVoter
  );
}

findWhitelistAddress = async (
  locker: PublicKey,
  programId: PublicKey,
  owner: PublicKey | null
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("LockerWhitelistEntry"),
      locker.toBuffer(),
      programId.toBuffer(),
      owner ? owner.toBuffer() : SystemProgram.programId.toBuffer(),
    ],
    TRIBECA_ADDRESSES.LockedVoter
  );
}

findEscrowAddress = async (
  locker: PublicKey,
  authority: PublicKey
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("Escrow"),
      locker.toBuffer(),
      authority.toBuffer(),
    ],
    TRIBECA_ADDRESSES.LockedVoter
  );
}

findVoteAddress = async (
  proposalKey: PublicKey,
  voterKey: PublicKey
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("TribecaVote"),
      proposalKey.toBuffer(),
      voterKey.toBuffer(),
    ],
    TRIBECA_ADDRESSES.Govern
  );
}

findProposalAddress = async (
  governorKey: PublicKey,
  index: u64
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("TribecaProposal"),
      governorKey.toBuffer(),
      index.toArrayLike(Buffer, "le", 8),
    ],
    TRIBECA_ADDRESSES.Govern
  );
}

findSwapMetaAddress = async ({
  factory,
  index,
  programId = PROGRAM_ADDRESSES.CpAmm,
}: {
  factory: PublicKey;
  index: number;
  programId?: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("SwapMeta"),
      factory.toBuffer(),
      new u64(index).toBuffer(),
    ],
    programId
  );
}

findSwapAddress = async ({
  factory,
  mintA,
  mintB,
  programId = PROGRAM_ADDRESSES.CpAmm,
}: {
  factory: PublicKey;
  mintA: PublicKey;
  mintB: PublicKey;
  programId?: PublicKey;
}): Promise<[PublicKey, number]> => {
  const [token0Mint, token1Mint] =
    comparePubkeys(mintA, mintB) !== -1 ? [mintB, mintA] : [mintA, mintB];

  return await PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("SwapInfo"),
      factory.toBuffer(),
      token0Mint.toBuffer(),
      token1Mint.toBuffer(),
    ],
    programId
  );
}

findFactoryAddress = async ({
  base,
  programId = PROGRAM_ADDRESSES.CpAmm,
}: {
  base: PublicKey;
  programId?: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("Factory"), base.toBuffer()],
    programId
  );
}

findPoolAddress = async ({
  programId = QUARRY_ADDRESSES.MergeMine,
  primaryMint,
}: {
  programId?: PublicKey;
  primaryMint: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("MergePool"), primaryMint.toBuffer()],
    programId
  );
}

findMergeMinerAddress = async ({
  programId = QUARRY_ADDRESSES.MergeMine,
  pool,
  owner,
}: {
  programId?: PublicKey;
  pool: PublicKey;
  owner: PublicKey;
}): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("MergeMiner"), pool.toBuffer(), owner.toBuffer()],
    programId
  );
}

findRegistryAddress = async (
  rewarderKey: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.Registry
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("QuarryRegistry"), rewarderKey.toBytes()],
    programID
  );
}

findRedeemerKey = async ({
  iouMint,
  redemptionMint,
}: {
  iouMint: PublicKey;
  redemptionMint: PublicKey;
}): Promise<[PublicKey, number]> => {
  return PublicKey.findProgramAddress(
    [
      utils.bytes.utf8.encode("Redeemer"),
      iouMint.toBytes(),
      redemptionMint.toBytes(),
    ],
    QUARRY_ADDRESSES.Redeemer
  );
}

findRewarderAddress = async (
  base: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.Mine
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [Buffer.from(utils.bytes.utf8.encode("Rewarder")), base.toBytes()],
    programID
  );
}

findOperatorAddress = async (
  base: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.Operator
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("Operator"), base.toBytes()],
    programID
  );
}

findMinterAddress = async (
  wrapper: PublicKey,
  authority: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.MintWrapper
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      Buffer.from(utils.bytes.utf8.encode("MintWrapperMinter")),
      wrapper.toBytes(),
      authority.toBytes(),
    ],
    programID
  );
}

findMintWrapperAddress = async (
  base: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.MintWrapper
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [Buffer.from(utils.bytes.utf8.encode("MintWrapper")), base.toBytes()],
    programID
  );
}

findMinerAddress = async (
  quarry: PublicKey,
  authority: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.Mine
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      Buffer.from(utils.bytes.utf8.encode("Miner")),
      quarry.toBytes(),
      authority.toBytes(),
    ],
    programID
  );
}

findQuarryAddress = async (
  rewarder: PublicKey,
  tokenMint: PublicKey,
  programID: PublicKey = QUARRY_ADDRESSES.Mine
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [
      Buffer.from(utils.bytes.utf8.encode("Quarry")),
      rewarder.toBytes(),
      tokenMint.toBytes(),
    ],
    programID
  );
}

async getProxyMintAuthority(): Promise<[PublicKey, number]> {
    const stateAccount = this.program.state.address();
    return await PublicKey.findProgramAddress(
      [utils.bytes.utf8.encode("SaberMintProxy"), stateAccount.toBuffer()],
      this.program.programId
    );
  }

initOpenOrders(ix: TransactionInstruction) {
    const market = ix.keys[2].pubkey;
    const owner = ix.keys[1].pubkey;
    // b"open-orders"
    const openOrdersSeed = Buffer.from([
      111,
      112,
      101,
      110,
      45,
      111,
      114,
      100,
      101,
      114,
      115,
    ]);

    // b"open-orders-init"
    const openOrdersInitSeed = Buffer.from([
      111,
      112,
      101,
      110,
      45,
      111,
      114,
      100,
      101,
      114,
      115,
      45,
      105,
      110,
      105,
      116,
    ]);
    const [openOrders, bump] = utils.publicKey.findProgramAddressSync(
      [
        openOrdersSeed,
        this._dexProgramId.toBuffer(),
        market.toBuffer(),
        owner.toBuffer(),
      ],
      this._proxyProgramId,
    );
    const [marketAuthority, bumpInit] = utils.publicKey.findProgramAddressSync(
      [openOrdersInitSeed, this._dexProgramId.toBuffer(), market.toBuffer()],
      this._proxyProgramId,
    );

    // Override the open orders account and market authority.
    ix.keys[0].pubkey = openOrders;
    ix.keys[4].pubkey = marketAuthority;

    // Writable because it must pay for the PDA initialization.
    ix.keys[1].isWritable = true;

    // Prepend to the account list extra accounts needed for PDA initialization.
    ix.keys = [
      { pubkey: this._dexProgramId, isSigner: false, isWritable: false },
      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
      ...ix.keys,
    ];
    // Prepend the ix discriminator, bump, and bumpInit to the instruction data,
    // which saves the program compute by avoiding recalculating them in the
    // program.
    ix.data = Buffer.concat([Buffer.from([0, bump, bumpInit]), ix.data]);
  }

findSimpleElectorateAddress = async (
  base: PublicKey
): Promise<[PublicKey, number]> => {
  return await PublicKey.findProgramAddress(
    [utils.bytes.utf8.encode("SimpleElectorate"), base.toBuffer()],
    TRIBECA_ADDRESSES.SimpleVoter
  );
}