fix(rpc): handle contract addresses in requestAirdrop()

  requestAirdrop() now properly supports C... (contract) addresses by
  detecting them via StrKey.isValidContract() and returning a
  ContractFundingResult instead of attempting to find a created account.

  Fixes funding contract addresses which previously threw
  'No account created in transaction' error.

Author: yripper

src/rpc/api.ts

@@ -48,6 +48,14 @@ export namespace Api {
     protocolVersion: string;
   }
 
+  /**
+   * Result returned when funding a contract address via friendbot.
+   */
+  export interface ContractFundingResult {
+    contractId: string;
+    hash: string;
+  }
+
   /** @see https://developers.stellar.org/docs/data/rpc/api-reference/methods/getLatestLedger */
   export interface GetLatestLedgerResponse {
     id: string;

src/rpc/server.ts

@@ -1194,37 +1194,52 @@ export class RpcServer {
   }
 
   /**
-   * Fund a new account using the network's Friendbot faucet, if any.
+   * Fund a new account or contract using the network's Friendbot faucet, if any.
    *
    * @param {string | Account} address The address or account instance that we
-   *    want to create and fund with Friendbot
+   *    want to create and fund with Friendbot. Supports both G... (account) and
+   *    C... (contract) addresses.
    * @param {string} [friendbotUrl] Optionally, an explicit address for
    *    friendbot (by default: this calls the Soroban RPC
    *    {@link module:rpc.Server#getNetwork | getNetwork} method to try to
    *    discover this network's Friendbot url).
-   * @returns {Promise<Account>} An {@link Account} object for the created
-   *    account, or the existing account if it's already funded with the
-   *    populated sequence number (note that the account will not be "topped
-   *    off" if it already exists)
+   * @returns {Promise<Account | Api.ContractFundingResult>} An {@link Account}
+   *    object for the created account (G... addresses), or a
+   *    {@link Api.ContractFundingResult} for contract addresses (C...). For
+   *    existing accounts, returns the account with populated sequence number
+   *    (note that accounts will not be "topped off" if they already exist).
    * @throws {Error} If Friendbot is not configured on this network or request failure
    *
    * @see {@link https://developers.stellar.org/docs/learn/fundamentals/networks#friendbot | Friendbot docs}
    * @see {@link module:Friendbot.Api.Response}
    *
    * @example
+   * // Funding an account (G... address)
    * server
    *    .requestAirdrop("GBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4")
-   *    .then((accountCreated) => {
-   *      console.log("accountCreated:", accountCreated);
-   *    }).catch((error) => {
-   *      console.error("error:", error);
+   *    .then((result) => {
+   *      if (result instanceof Account) {
+   *        console.log("accountCreated:", result.accountId());
+   *      }
+   *    });
+   *
+   * @example
+   * // Funding a contract (C... address)
+   * server
+   *    .requestAirdrop("CBZC6Y2Y7Q3ZQ2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4QZJ2XZ3Z5YXZ6Z7Z2Y4")
+   *    .then((result) => {
+   *      if ('contractId' in result) {
+   *        console.log("contractFunded:", result.contractId, "hash:", result.hash);
+   *      }
    *    });
    */
   public async requestAirdrop(
     address: string | Pick<Account, "accountId">,
     friendbotUrl?: string,
-  ): Promise<Account> {
+  ): Promise<Account | Api.ContractFundingResult> {
     const account = typeof address === "string" ? address : address.accountId();
+    const isContract = StrKey.isValidContract(account);
+
     friendbotUrl = friendbotUrl || (await this.getNetwork()).friendbotUrl;
     if (!friendbotUrl) {
       throw new Error("No friendbot URL configured for current network");
@@ -1235,6 +1250,14 @@ export class RpcServer {
         `${friendbotUrl}?addr=${encodeURIComponent(account)}`,
       );
 
+      // Contract addresses don't create accounts - they receive funds via SAC transfer
+      if (isContract) {
+        return {
+          contractId: account,
+          hash: response.data.hash,
+        };
+      }
+
       let meta: xdr.TransactionMeta;
       if (!response.data.result_meta_xdr) {
         const txMeta = await this.getTransaction(response.data.hash);

test/unit/server/soroban/request_airdrop.test.ts

@@ -369,4 +369,72 @@ describe("Server#requestAirdrop", () => {
     });
     expect(mockPost).toHaveBeenCalledTimes(3);
   });
+
+  it("returns ContractFundingResult for contract addresses (C...)", async () => {
+    const friendbotUrl = "https://friendbot.stellar.org";
+    // Valid contract address (C...)
+    const contractId = StellarSdk.StrKey.encodeContract(
+      Buffer.from("0".repeat(64), "hex"),
+    );
+    const hash =
+      "ae9f315c048d87a5f853bc15bf284a2c3c89eb0e1cb38c10409b77a877b830a8";
+
+    const networkResult = {
+      friendbotUrl,
+      passphrase: Networks.FUTURENET,
+      protocolVersion: 20,
+    };
+    const networkResponse = { data: { result: networkResult } };
+
+    // Mock the friendbot call - contract funding returns hash but no account creation
+    const friendbotResponse = {
+      status: 200,
+      data: {
+        hash,
+        result_meta_xdr: "someXdr", // Doesn't matter - should not be parsed for contracts
+      },
+    };
+
+    mockPost
+      .mockResolvedValueOnce(networkResponse) // getNetwork call
+      .mockResolvedValueOnce(friendbotResponse); // friendbot call
+
+    const result = await server.requestAirdrop(contractId);
+
+    // Should return ContractFundingResult, not Account
+    expect(result).not.toBeInstanceOf(StellarSdk.Account);
+    expect(result).toHaveProperty("contractId", contractId);
+    expect(result).toHaveProperty("hash", hash);
+    expect(mockPost).toHaveBeenCalledWith(serverUrl, {
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getNetwork",
+      params: null,
+    });
+    expect(mockPost).toHaveBeenCalledWith(`${friendbotUrl}?addr=${contractId}`);
+    expect(mockPost).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not throw 'No account created' for contract addresses", async () => {
+    const customFriendbotUrl = "https://custom-friendbot.example.com";
+    const contractId = StellarSdk.StrKey.encodeContract(
+      Buffer.from("1".repeat(64), "hex"),
+    );
+    const hash = "somehash123";
+
+    const friendbotResponse = {
+      status: 200,
+      data: { hash },
+    };
+
+    mockPost.mockResolvedValueOnce(friendbotResponse);
+
+    // Should NOT throw "No account created in transaction"
+    const result = await server.requestAirdrop(contractId, customFriendbotUrl);
+
+    expect(result).toEqual({
+      contractId,
+      hash,
+    });
+  });
 });